LCOV - code coverage report
Current view: top level - contrib/isn - isn.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 370 481 76.9 %
Date: 2019-10-18 16:07:03 Functions: 40 45 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * isn.c
       4             :  *    PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
       5             :  *
       6             :  * Author:  German Mendez Bravo (Kronuz)
       7             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    contrib/isn/isn.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : 
      15             : #include "postgres.h"
      16             : 
      17             : #include "fmgr.h"
      18             : #include "utils/builtins.h"
      19             : 
      20             : #include "isn.h"
      21             : #include "EAN13.h"
      22             : #include "ISBN.h"
      23             : #include "ISMN.h"
      24             : #include "ISSN.h"
      25             : #include "UPC.h"
      26             : 
      27           2 : PG_MODULE_MAGIC;
      28             : 
      29             : #ifdef USE_ASSERT_CHECKING
      30             : #define ISN_DEBUG 1
      31             : #else
      32             : #define ISN_DEBUG 0
      33             : #endif
      34             : 
      35             : #define MAXEAN13LEN 18
      36             : 
      37             : enum isn_type
      38             : {
      39             :     INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC
      40             : };
      41             : 
      42             : static const char *const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"};
      43             : 
      44             : static bool g_weak = false;
      45             : 
      46             : 
      47             : /***********************************************************************
      48             :  **
      49             :  **     Routines for EAN13/UPC/ISxNs.
      50             :  **
      51             :  ** Note:
      52             :  **  In this code, a normalized string is one that is known to be a valid
      53             :  **  ISxN number containing only digits and hyphens and with enough space
      54             :  **  to hold the full 13 digits plus the maximum of four hyphens.
      55             :  ***********************************************************************/
      56             : 
      57             : /*----------------------------------------------------------
      58             :  * Debugging routines.
      59             :  *---------------------------------------------------------*/
      60             : 
      61             : /*
      62             :  * Check if the table and its index is correct (just for debugging)
      63             :  */
      64             : pg_attribute_unused()
      65             : static bool
      66           0 : check_table(const char *(*TABLE)[2], const unsigned TABLE_index[10][2])
      67             : {
      68             :     const char *aux1,
      69             :                *aux2;
      70             :     int         a,
      71             :                 b,
      72           0 :                 x = 0,
      73           0 :                 y = -1,
      74           0 :                 i = 0,
      75             :                 j,
      76           0 :                 init = 0;
      77             : 
      78           0 :     if (TABLE == NULL || TABLE_index == NULL)
      79           0 :         return true;
      80             : 
      81           0 :     while (TABLE[i][0] && TABLE[i][1])
      82             :     {
      83           0 :         aux1 = TABLE[i][0];
      84           0 :         aux2 = TABLE[i][1];
      85             : 
      86             :         /* must always start with a digit: */
      87           0 :         if (!isdigit((unsigned char) *aux1) || !isdigit((unsigned char) *aux2))
      88             :             goto invalidtable;
      89           0 :         a = *aux1 - '0';
      90           0 :         b = *aux2 - '0';
      91             : 
      92             :         /* must always have the same format and length: */
      93           0 :         while (*aux1 && *aux2)
      94             :         {
      95           0 :             if (!(isdigit((unsigned char) *aux1) &&
      96           0 :                   isdigit((unsigned char) *aux2)) &&
      97           0 :                 (*aux1 != *aux2 || *aux1 != '-'))
      98             :                 goto invalidtable;
      99           0 :             aux1++;
     100           0 :             aux2++;
     101             :         }
     102           0 :         if (*aux1 != *aux2)
     103           0 :             goto invalidtable;
     104             : 
     105             :         /* found a new range */
     106           0 :         if (a > y)
     107             :         {
     108             :             /* check current range in the index: */
     109           0 :             for (j = x; j <= y; j++)
     110             :             {
     111           0 :                 if (TABLE_index[j][0] != init)
     112           0 :                     goto invalidindex;
     113           0 :                 if (TABLE_index[j][1] != i - init)
     114           0 :                     goto invalidindex;
     115             :             }
     116           0 :             init = i;
     117           0 :             x = a;
     118             :         }
     119             : 
     120             :         /* Always get the new limit */
     121           0 :         y = b;
     122           0 :         if (y < x)
     123           0 :             goto invalidtable;
     124           0 :         i++;
     125             :     }
     126             : 
     127           0 :     return true;
     128             : 
     129             : invalidtable:
     130           0 :     elog(DEBUG1, "invalid table near {\"%s\", \"%s\"} (pos: %d)",
     131             :          TABLE[i][0], TABLE[i][1], i);
     132           0 :     return false;
     133             : 
     134             : invalidindex:
     135           0 :     elog(DEBUG1, "index %d is invalid", j);
     136           0 :     return false;
     137             : }
     138             : 
     139             : /*----------------------------------------------------------
     140             :  * Formatting and conversion routines.
     141             :  *---------------------------------------------------------*/
     142             : 
     143             : static unsigned
     144           4 : dehyphenate(char *bufO, char *bufI)
     145             : {
     146           4 :     unsigned    ret = 0;
     147             : 
     148          64 :     while (*bufI)
     149             :     {
     150          56 :         if (isdigit((unsigned char) *bufI))
     151             :         {
     152          48 :             *bufO++ = *bufI;
     153          48 :             ret++;
     154             :         }
     155          56 :         bufI++;
     156             :     }
     157           4 :     *bufO = '\0';
     158           4 :     return ret;
     159             : }
     160             : 
     161             : /*
     162             :  * hyphenate --- Try to hyphenate, in-place, the string starting at bufI
     163             :  *                into bufO using the given hyphenation range TABLE.
     164             :  *                Assumes the input string to be used is of only digits.
     165             :  *
     166             :  * Returns the number of characters actually hyphenated.
     167             :  */
     168             : static unsigned
     169         166 : hyphenate(char *bufO, char *bufI, const char *(*TABLE)[2], const unsigned TABLE_index[10][2])
     170             : {
     171         166 :     unsigned    ret = 0;
     172             :     const char *ean_aux1,
     173             :                *ean_aux2,
     174             :                *ean_p;
     175             :     char       *firstdig,
     176             :                *aux1,
     177             :                *aux2;
     178             :     unsigned    search,
     179             :                 upper,
     180             :                 lower,
     181             :                 step;
     182             :     bool        ean_in1,
     183             :                 ean_in2;
     184             : 
     185             :     /* just compress the string if no further hyphenation is required */
     186         166 :     if (TABLE == NULL || TABLE_index == NULL)
     187             :     {
     188         560 :         while (*bufI)
     189             :         {
     190         480 :             *bufO++ = *bufI++;
     191         480 :             ret++;
     192             :         }
     193          40 :         *bufO = '\0';
     194          40 :         return (ret + 1);
     195             :     }
     196             : 
     197             :     /* add remaining hyphenations */
     198             : 
     199         126 :     search = *bufI - '0';
     200         126 :     upper = lower = TABLE_index[search][0];
     201         126 :     upper += TABLE_index[search][1];
     202         126 :     lower--;
     203             : 
     204         126 :     step = (upper - lower) / 2;
     205         126 :     if (step == 0)
     206           6 :         return 0;
     207         120 :     search = lower + step;
     208             : 
     209         120 :     firstdig = bufI;
     210         120 :     ean_in1 = ean_in2 = false;
     211         120 :     ean_aux1 = TABLE[search][0];
     212         120 :     ean_aux2 = TABLE[search][1];
     213             :     do
     214             :     {
     215         712 :         if ((ean_in1 || *firstdig >= *ean_aux1) && (ean_in2 || *firstdig <= *ean_aux2))
     216             :         {
     217         522 :             if (*firstdig > *ean_aux1)
     218          68 :                 ean_in1 = true;
     219         522 :             if (*firstdig < *ean_aux2)
     220          68 :                 ean_in2 = true;
     221         522 :             if (ean_in1 && ean_in2)
     222          52 :                 break;
     223             : 
     224         470 :             firstdig++, ean_aux1++, ean_aux2++;
     225         470 :             if (!(*ean_aux1 && *ean_aux2 && *firstdig))
     226             :                 break;
     227         828 :             if (!isdigit((unsigned char) *ean_aux1))
     228          80 :                 ean_aux1++, ean_aux2++;
     229             :         }
     230             :         else
     231             :         {
     232             :             /*
     233             :              * check in what direction we should go and move the pointer
     234             :              * accordingly
     235             :              */
     236         190 :             if (*firstdig < *ean_aux1 && !ean_in1)
     237          64 :                 upper = search;
     238             :             else
     239         126 :                 lower = search;
     240             : 
     241         190 :             step = (upper - lower) / 2;
     242         190 :             search = lower + step;
     243             : 
     244             :             /* Initialize stuff again: */
     245         190 :             firstdig = bufI;
     246         190 :             ean_in1 = ean_in2 = false;
     247         190 :             ean_aux1 = TABLE[search][0];
     248         190 :             ean_aux2 = TABLE[search][1];
     249             :         }
     250         604 :     } while (step);
     251             : 
     252         120 :     if (step)
     253             :     {
     254         108 :         aux1 = bufO;
     255         108 :         aux2 = bufI;
     256         108 :         ean_p = TABLE[search][0];
     257         676 :         while (*ean_p && *aux2)
     258             :         {
     259         460 :             if (*ean_p++ != '-')
     260         416 :                 *aux1++ = *aux2++;
     261             :             else
     262          44 :                 *aux1++ = '-';
     263         460 :             ret++;
     264             :         }
     265         108 :         *aux1++ = '-';
     266         108 :         *aux1 = *aux2;          /* add a lookahead char */
     267         108 :         return (ret + 1);
     268             :     }
     269          12 :     return ret;
     270             : }
     271             : 
     272             : /*
     273             :  * weight_checkdig -- Receives a buffer with a normalized ISxN string number,
     274             :  *                     and the length to weight.
     275             :  *
     276             :  * Returns the weight of the number (the check digit value, 0-10)
     277             :  */
     278             : static unsigned
     279          28 : weight_checkdig(char *isn, unsigned size)
     280             : {
     281          28 :     unsigned    weight = 0;
     282             : 
     283         304 :     while (*isn && size > 1)
     284             :     {
     285         248 :         if (isdigit((unsigned char) *isn))
     286             :         {
     287         228 :             weight += size-- * (*isn - '0');
     288             :         }
     289         248 :         isn++;
     290             :     }
     291          28 :     weight = weight % 11;
     292          28 :     if (weight != 0)
     293          28 :         weight = 11 - weight;
     294          28 :     return weight;
     295             : }
     296             : 
     297             : 
     298             : /*
     299             :  * checkdig --- Receives a buffer with a normalized ISxN string number,
     300             :  *               and the length to check.
     301             :  *
     302             :  * Returns the check digit value (0-9)
     303             :  */
     304             : static unsigned
     305         200 : checkdig(char *num, unsigned size)
     306             : {
     307         200 :     unsigned    check = 0,
     308         200 :                 check3 = 0;
     309         200 :     unsigned    pos = 0;
     310             : 
     311         200 :     if (*num == 'M')
     312             :     {                           /* ISMN start with 'M' */
     313           0 :         check3 = 3;
     314           0 :         pos = 1;
     315             :     }
     316        2800 :     while (*num && size > 1)
     317             :     {
     318        2400 :         if (isdigit((unsigned char) *num))
     319             :         {
     320        2400 :             if (pos++ % 2)
     321        1200 :                 check3 += *num - '0';
     322             :             else
     323        1200 :                 check += *num - '0';
     324        2400 :             size--;
     325             :         }
     326        2400 :         num++;
     327             :     }
     328         200 :     check = (check + 3 * check3) % 10;
     329         200 :     if (check != 0)
     330         200 :         check = 10 - check;
     331         200 :     return check;
     332             : }
     333             : 
     334             : /*
     335             :  * ean2isn --- Try to convert an ean13 number to a UPC/ISxN number.
     336             :  *             This doesn't verify for a valid check digit.
     337             :  *
     338             :  * If errorOK is false, ereport a useful error message if the ean13 is bad.
     339             :  * If errorOK is true, just return "false" for bad input.
     340             :  */
     341             : static bool
     342          12 : ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept)
     343             : {
     344          12 :     enum isn_type type = INVALID;
     345             : 
     346             :     char        buf[MAXEAN13LEN + 1];
     347             :     char       *aux;
     348             :     unsigned    digval;
     349             :     unsigned    search;
     350          12 :     ean13       ret = ean;
     351             : 
     352          12 :     ean >>= 1;
     353             :     /* verify it's in the EAN13 range */
     354          12 :     if (ean > UINT64CONST(9999999999999))
     355           0 :         goto eantoobig;
     356             : 
     357             :     /* convert the number */
     358          12 :     search = 0;
     359          12 :     aux = buf + 13;
     360          12 :     *aux = '\0';                /* terminate string; aux points to last digit */
     361             :     do
     362             :     {
     363         154 :         digval = (unsigned) (ean % 10); /* get the decimal value */
     364         154 :         ean /= 10;              /* get next digit */
     365         154 :         *--aux = (char) (digval + '0'); /* convert to ascii and store */
     366         154 :     } while (ean && search++ < 12);
     367          26 :     while (search++ < 12)
     368           2 :         *--aux = '0';           /* fill the remaining EAN13 with '0' */
     369             : 
     370             :     /* find out the data type: */
     371          12 :     if (strncmp("978", buf, 3) == 0)
     372             :     {                           /* ISBN */
     373           2 :         type = ISBN;
     374             :     }
     375          10 :     else if (strncmp("977", buf, 3) == 0)
     376             :     {                           /* ISSN */
     377           2 :         type = ISSN;
     378             :     }
     379           8 :     else if (strncmp("9790", buf, 4) == 0)
     380             :     {                           /* ISMN */
     381           2 :         type = ISMN;
     382             :     }
     383           6 :     else if (strncmp("979", buf, 3) == 0)
     384             :     {                           /* ISBN-13 */
     385           4 :         type = ISBN;
     386             :     }
     387           2 :     else if (*buf == '0')
     388             :     {                           /* UPC */
     389           2 :         type = UPC;
     390             :     }
     391             :     else
     392             :     {
     393           0 :         type = EAN13;
     394             :     }
     395          12 :     if (accept != ANY && accept != EAN13 && accept != type)
     396           0 :         goto eanwrongtype;
     397             : 
     398          12 :     *result = ret;
     399          12 :     return true;
     400             : 
     401             : eanwrongtype:
     402           0 :     if (!errorOK)
     403             :     {
     404           0 :         if (type != EAN13)
     405             :         {
     406           0 :             ereport(ERROR,
     407             :                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     408             :                      errmsg("cannot cast EAN13(%s) to %s for number: \"%s\"",
     409             :                             isn_names[type], isn_names[accept], buf)));
     410             :         }
     411             :         else
     412             :         {
     413           0 :             ereport(ERROR,
     414             :                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     415             :                      errmsg("cannot cast %s to %s for number: \"%s\"",
     416             :                             isn_names[type], isn_names[accept], buf)));
     417             :         }
     418             :     }
     419           0 :     return false;
     420             : 
     421             : eantoobig:
     422           0 :     if (!errorOK)
     423             :     {
     424             :         char        eanbuf[64];
     425             : 
     426             :         /*
     427             :          * Format the number separately to keep the machine-dependent format
     428             :          * code out of the translatable message text
     429             :          */
     430           0 :         snprintf(eanbuf, sizeof(eanbuf), EAN13_FORMAT, ean);
     431           0 :         ereport(ERROR,
     432             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
     433             :                  errmsg("value \"%s\" is out of range for %s type",
     434             :                         eanbuf, isn_names[type])));
     435             :     }
     436           0 :     return false;
     437             : }
     438             : 
     439             : /*
     440             :  * ean2UPC/ISxN --- Convert in-place a normalized EAN13 string to the corresponding
     441             :  *                  UPC/ISxN string number. Assumes the input string is normalized.
     442             :  */
     443             : static inline void
     444          14 : ean2ISBN(char *isn)
     445             : {
     446             :     char       *aux;
     447             :     unsigned    check;
     448             : 
     449             :     /*
     450             :      * The number should come in this format: 978-0-000-00000-0 or may be an
     451             :      * ISBN-13 number, 979-..., which does not have a short representation. Do
     452             :      * the short output version if possible.
     453             :      */
     454          14 :     if (strncmp("978-", isn, 4) == 0)
     455             :     {
     456             :         /* Strip the first part and calculate the new check digit */
     457           8 :         hyphenate(isn, isn + 4, NULL, NULL);
     458           8 :         check = weight_checkdig(isn, 10);
     459           8 :         aux = strchr(isn, '\0');
     460           8 :         while (!isdigit((unsigned char) *--aux));
     461           8 :         if (check == 10)
     462           2 :             *aux = 'X';
     463             :         else
     464           6 :             *aux = check + '0';
     465             :     }
     466          14 : }
     467             : 
     468             : static inline void
     469           8 : ean2ISMN(char *isn)
     470             : {
     471             :     /* the number should come in this format: 979-0-000-00000-0 */
     472             :     /* Just strip the first part and change the first digit ('0') to 'M' */
     473           8 :     hyphenate(isn, isn + 4, NULL, NULL);
     474           8 :     isn[0] = 'M';
     475           8 : }
     476             : 
     477             : static inline void
     478           4 : ean2ISSN(char *isn)
     479             : {
     480             :     unsigned    check;
     481             : 
     482             :     /* the number should come in this format: 977-0000-000-00-0 */
     483             :     /* Strip the first part, crop, and calculate the new check digit */
     484           4 :     hyphenate(isn, isn + 4, NULL, NULL);
     485           4 :     check = weight_checkdig(isn, 8);
     486           4 :     if (check == 10)
     487           0 :         isn[8] = 'X';
     488             :     else
     489           4 :         isn[8] = check + '0';
     490           4 :     isn[9] = '\0';
     491           4 : }
     492             : 
     493             : static inline void
     494           4 : ean2UPC(char *isn)
     495             : {
     496             :     /* the number should come in this format: 000-000000000-0 */
     497             :     /* Strip the first part, crop, and dehyphenate */
     498           4 :     dehyphenate(isn, isn + 1);
     499           4 :     isn[12] = '\0';
     500           4 : }
     501             : 
     502             : /*
     503             :  * ean2* --- Converts a string of digits into an ean13 number.
     504             :  *            Assumes the input string is a string with only digits
     505             :  *            on it, and that it's within the range of ean13.
     506             :  *
     507             :  * Returns the ean13 value of the string.
     508             :  */
     509             : static ean13
     510          76 : str2ean(const char *num)
     511             : {
     512          76 :     ean13       ean = 0;        /* current ean */
     513             : 
     514        1140 :     while (*num)
     515             :     {
     516         988 :         if (isdigit((unsigned char) *num))
     517         988 :             ean = 10 * ean + (*num - '0');
     518         988 :         num++;
     519             :     }
     520          76 :     return (ean << 1);            /* also give room to a flag */
     521             : }
     522             : 
     523             : /*
     524             :  * ean2string --- Try to convert an ean13 number to a hyphenated string.
     525             :  *                Assumes there's enough space in result to hold
     526             :  *                the string (maximum MAXEAN13LEN+1 bytes)
     527             :  *                This doesn't verify for a valid check digit.
     528             :  *
     529             :  * If shortType is true, the returned string is in the old ISxN short format.
     530             :  * If errorOK is false, ereport a useful error message if the string is bad.
     531             :  * If errorOK is true, just return "false" for bad input.
     532             :  */
     533             : static bool
     534          64 : ean2string(ean13 ean, bool errorOK, char *result, bool shortType)
     535             : {
     536             :     const char *(*TABLE)[2];
     537             :     const unsigned (*TABLE_index)[2];
     538          64 :     enum isn_type type = INVALID;
     539             : 
     540             :     char       *aux;
     541             :     unsigned    digval;
     542             :     unsigned    search;
     543          64 :     char        valid = '\0';   /* was the number initially written with a
     544             :                                  * valid check digit? */
     545             : 
     546          64 :     TABLE_index = ISBN_index;
     547             : 
     548          64 :     if ((ean & 1) != 0)
     549           0 :         valid = '!';
     550          64 :     ean >>= 1;
     551             :     /* verify it's in the EAN13 range */
     552          64 :     if (ean > UINT64CONST(9999999999999))
     553           0 :         goto eantoobig;
     554             : 
     555             :     /* convert the number */
     556          64 :     search = 0;
     557          64 :     aux = result + MAXEAN13LEN;
     558          64 :     *aux = '\0';                /* terminate string; aux points to last digit */
     559          64 :     *--aux = valid;             /* append '!' for numbers with invalid but
     560             :                                  * corrected check digit */
     561             :     do
     562             :     {
     563         826 :         digval = (unsigned) (ean % 10); /* get the decimal value */
     564         826 :         ean /= 10;              /* get next digit */
     565         826 :         *--aux = (char) (digval + '0'); /* convert to ascii and store */
     566         826 :         if (search == 0)
     567          64 :             *--aux = '-';       /* the check digit is always there */
     568         826 :     } while (ean && search++ < 13);
     569         198 :     while (search++ < 13)
     570          70 :         *--aux = '0';           /* fill the remaining EAN13 with '0' */
     571             : 
     572             :     /* The string should be in this form: ???DDDDDDDDDDDD-D" */
     573          64 :     search = hyphenate(result, result + 3, EAN13_range, EAN13_index);
     574             : 
     575             :     /* verify it's a logically valid EAN13 */
     576          64 :     if (search == 0)
     577             :     {
     578           0 :         search = hyphenate(result, result + 3, NULL, NULL);
     579           0 :         goto okay;
     580             :     }
     581             : 
     582             :     /* find out what type of hyphenation is needed: */
     583          64 :     if (strncmp("978-", result, search) == 0)
     584             :     {                           /* ISBN -13 978-range */
     585             :         /* The string should be in this form: 978-??000000000-0" */
     586          14 :         type = ISBN;
     587          14 :         TABLE = ISBN_range;
     588          14 :         TABLE_index = ISBN_index;
     589             :     }
     590          50 :     else if (strncmp("977-", result, search) == 0)
     591             :     {                           /* ISSN */
     592             :         /* The string should be in this form: 977-??000000000-0" */
     593          14 :         type = ISSN;
     594          14 :         TABLE = ISSN_range;
     595          14 :         TABLE_index = ISSN_index;
     596             :     }
     597          36 :     else if (strncmp("979-0", result, search + 1) == 0)
     598             :     {                           /* ISMN */
     599             :         /* The string should be in this form: 979-0?000000000-0" */
     600          16 :         type = ISMN;
     601          16 :         TABLE = ISMN_range;
     602          16 :         TABLE_index = ISMN_index;
     603             :     }
     604          20 :     else if (strncmp("979-", result, search) == 0)
     605             :     {                           /* ISBN-13 979-range */
     606             :         /* The string should be in this form: 979-??000000000-0" */
     607          12 :         type = ISBN;
     608          12 :         TABLE = ISBN_range_new;
     609          12 :         TABLE_index = ISBN_index_new;
     610             :     }
     611           8 :     else if (*result == '0')
     612             :     {                           /* UPC */
     613             :         /* The string should be in this form: 000-00000000000-0" */
     614           6 :         type = UPC;
     615           6 :         TABLE = UPC_range;
     616           6 :         TABLE_index = UPC_index;
     617             :     }
     618             :     else
     619             :     {
     620           2 :         type = EAN13;
     621           2 :         TABLE = NULL;
     622           2 :         TABLE_index = NULL;
     623             :     }
     624             : 
     625             :     /* verify it's a logically valid EAN13/UPC/ISxN */
     626          64 :     digval = search;
     627          64 :     search = hyphenate(result + digval, result + digval + 2, TABLE, TABLE_index);
     628             : 
     629             :     /* verify it's a valid EAN13 */
     630          64 :     if (search == 0)
     631             :     {
     632          18 :         search = hyphenate(result + digval, result + digval + 2, NULL, NULL);
     633          18 :         goto okay;
     634             :     }
     635             : 
     636             : okay:
     637             :     /* convert to the old short type: */
     638          64 :     if (shortType)
     639          30 :         switch (type)
     640             :         {
     641             :             case ISBN:
     642          14 :                 ean2ISBN(result);
     643          14 :                 break;
     644             :             case ISMN:
     645           8 :                 ean2ISMN(result);
     646           8 :                 break;
     647             :             case ISSN:
     648           4 :                 ean2ISSN(result);
     649           4 :                 break;
     650             :             case UPC:
     651           4 :                 ean2UPC(result);
     652           4 :                 break;
     653             :             default:
     654           0 :                 break;
     655             :         }
     656          64 :     return true;
     657             : 
     658             : eantoobig:
     659           0 :     if (!errorOK)
     660             :     {
     661             :         char        eanbuf[64];
     662             : 
     663             :         /*
     664             :          * Format the number separately to keep the machine-dependent format
     665             :          * code out of the translatable message text
     666             :          */
     667           0 :         snprintf(eanbuf, sizeof(eanbuf), EAN13_FORMAT, ean);
     668           0 :         ereport(ERROR,
     669             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
     670             :                  errmsg("value \"%s\" is out of range for %s type",
     671             :                         eanbuf, isn_names[type])));
     672             :     }
     673           0 :     return false;
     674             : }
     675             : 
     676             : /*
     677             :  * string2ean --- try to parse a string into an ean13.
     678             :  *
     679             :  * If errorOK is false, ereport a useful error message if the string is bad.
     680             :  * If errorOK is true, just return "false" for bad input.
     681             :  *
     682             :  * if the input string ends with '!' it will always be treated as invalid
     683             :  * (even if the check digit is valid)
     684             :  */
     685             : static bool
     686         130 : string2ean(const char *str, bool errorOK, ean13 *result,
     687             :            enum isn_type accept)
     688             : {
     689             :     bool        digit,
     690             :                 last;
     691         130 :     char        buf[17] = "                ";
     692         130 :     char       *aux1 = buf + 3; /* leave space for the first part, in case
     693             :                                  * it's needed */
     694         130 :     const char *aux2 = str;
     695         130 :     enum isn_type type = INVALID;
     696         130 :     unsigned    check = 0,
     697         130 :                 rcheck = (unsigned) -1;
     698         130 :     unsigned    length = 0;
     699         130 :     bool        magic = false,
     700         130 :                 valid = true;
     701             : 
     702             :     /* recognize and validate the number: */
     703        1816 :     while (*aux2 && length <= 13)
     704             :     {
     705        1560 :         last = (*(aux2 + 1) == '!' || *(aux2 + 1) == '\0'); /* is the last character */
     706        1560 :         digit = (isdigit((unsigned char) *aux2) != 0);  /* is current character
     707             :                                                          * a digit? */
     708        1560 :         if (*aux2 == '?' && last)   /* automagically calculate check digit if
     709             :                                      * it's '?' */
     710           0 :             magic = digit = true;
     711        1560 :         if (length == 0 && (*aux2 == 'M' || *aux2 == 'm'))
     712             :         {
     713             :             /* only ISMN can be here */
     714          12 :             if (type != INVALID)
     715           0 :                 goto eaninvalid;
     716          12 :             type = ISMN;
     717          12 :             *aux1++ = 'M';
     718          12 :             length++;
     719             :         }
     720        1548 :         else if (length == 7 && (digit || *aux2 == 'X' || *aux2 == 'x') && last)
     721             :         {
     722             :             /* only ISSN can be here */
     723           8 :             if (type != INVALID)
     724           0 :                 goto eaninvalid;
     725           8 :             type = ISSN;
     726           8 :             *aux1++ = toupper((unsigned char) *aux2);
     727           8 :             length++;
     728             :         }
     729        1540 :         else if (length == 9 && (digit || *aux2 == 'X' || *aux2 == 'x') && last)
     730             :         {
     731             :             /* only ISBN and ISMN can be here */
     732          20 :             if (type != INVALID && type != ISMN)
     733           0 :                 goto eaninvalid;
     734          20 :             if (type == INVALID)
     735           8 :                 type = ISBN;    /* ISMN must start with 'M' */
     736          20 :             *aux1++ = toupper((unsigned char) *aux2);
     737          20 :             length++;
     738             :         }
     739        1520 :         else if (length == 11 && digit && last)
     740             :         {
     741             :             /* only UPC can be here */
     742           0 :             if (type != INVALID)
     743           0 :                 goto eaninvalid;
     744           0 :             type = UPC;
     745           0 :             *aux1++ = *aux2;
     746           0 :             length++;
     747             :         }
     748        1520 :         else if (*aux2 == '-' || *aux2 == ' ')
     749             :         {
     750             :             /* skip, we could validate but I think it's worthless */
     751             :         }
     752        1502 :         else if (*aux2 == '!' && *(aux2 + 1) == '\0')
     753             :         {
     754             :             /* the invalid check digit suffix was found, set it */
     755           0 :             if (!magic)
     756           0 :                 valid = false;
     757           0 :             magic = true;
     758             :         }
     759        1502 :         else if (!digit)
     760             :         {
     761           4 :             goto eaninvalid;
     762             :         }
     763             :         else
     764             :         {
     765        1498 :             *aux1++ = *aux2;
     766        1498 :             if (++length > 13)
     767           0 :                 goto eantoobig;
     768             :         }
     769        1556 :         aux2++;
     770             :     }
     771         126 :     *aux1 = '\0';               /* terminate the string */
     772             : 
     773             :     /* find the current check digit value */
     774         126 :     if (length == 13)
     775             :     {
     776             :         /* only EAN13 can be here */
     777          98 :         if (type != INVALID)
     778           0 :             goto eaninvalid;
     779          98 :         type = EAN13;
     780          98 :         check = buf[15] - '0';
     781             :     }
     782          28 :     else if (length == 12)
     783             :     {
     784             :         /* only UPC can be here */
     785           0 :         if (type != UPC)
     786           0 :             goto eaninvalid;
     787           0 :         check = buf[14] - '0';
     788             :     }
     789          28 :     else if (length == 10)
     790             :     {
     791          20 :         if (type != ISBN && type != ISMN)
     792           0 :             goto eaninvalid;
     793          20 :         if (buf[12] == 'X')
     794           6 :             check = 10;
     795             :         else
     796          14 :             check = buf[12] - '0';
     797             :     }
     798           8 :     else if (length == 8)
     799             :     {
     800           8 :         if (type != INVALID && type != ISSN)
     801           0 :             goto eaninvalid;
     802           8 :         type = ISSN;
     803           8 :         if (buf[10] == 'X')
     804           0 :             check = 10;
     805             :         else
     806           8 :             check = buf[10] - '0';
     807             :     }
     808             :     else
     809           0 :         goto eaninvalid;
     810             : 
     811         126 :     if (type == INVALID)
     812           0 :         goto eaninvalid;
     813             : 
     814             :     /* obtain the real check digit value, validate, and convert to ean13: */
     815         126 :     if (accept == EAN13 && type != accept)
     816           0 :         goto eanwrongtype;
     817         126 :     if (accept != ANY && type != EAN13 && type != accept)
     818           0 :         goto eanwrongtype;
     819         126 :     switch (type)
     820             :     {
     821             :         case EAN13:
     822          98 :             valid = (valid && ((rcheck = checkdig(buf + 3, 13)) == check || magic));
     823             :             /* now get the subtype of EAN13: */
     824          98 :             if (buf[3] == '0')
     825          16 :                 type = UPC;
     826          82 :             else if (strncmp("977", buf + 3, 3) == 0)
     827          20 :                 type = ISSN;
     828          62 :             else if (strncmp("978", buf + 3, 3) == 0)
     829          18 :                 type = ISBN;
     830          44 :             else if (strncmp("9790", buf + 3, 4) == 0)
     831          18 :                 type = ISMN;
     832          26 :             else if (strncmp("979", buf + 3, 3) == 0)
     833          22 :                 type = ISBN;
     834          98 :             if (accept != EAN13 && accept != ANY && type != accept)
     835          36 :                 goto eanwrongtype;
     836          62 :             break;
     837             :         case ISMN:
     838          12 :             memcpy(buf, "9790", 4); /* this isn't for sure yet, for now ISMN
     839             :                                      * it's only 9790 */
     840          12 :             valid = (valid && ((rcheck = checkdig(buf, 13)) == check || magic));
     841          12 :             break;
     842             :         case ISBN:
     843           8 :             memcpy(buf, "978", 3);
     844           8 :             valid = (valid && ((rcheck = weight_checkdig(buf + 3, 10)) == check || magic));
     845           8 :             break;
     846             :         case ISSN:
     847           8 :             memcpy(buf + 10, "00", 2);    /* append 00 as the normal issue
     848             :                                          * publication code */
     849           8 :             memcpy(buf, "977", 3);
     850           8 :             valid = (valid && ((rcheck = weight_checkdig(buf + 3, 8)) == check || magic));
     851           8 :             break;
     852             :         case UPC:
     853           0 :             buf[2] = '0';
     854           0 :             valid = (valid && ((rcheck = checkdig(buf + 2, 13)) == check || magic));
     855             :         default:
     856           0 :             break;
     857             :     }
     858             : 
     859             :     /* fix the check digit: */
     860          90 :     for (aux1 = buf; *aux1 && *aux1 <= ' '; aux1++);
     861          90 :     aux1[12] = checkdig(aux1, 13) + '0';
     862          90 :     aux1[13] = '\0';
     863             : 
     864          90 :     if (!valid && !magic)
     865          14 :         goto eanbadcheck;
     866             : 
     867          76 :     *result = str2ean(aux1);
     868          76 :     *result |= valid ? 0 : 1;
     869          76 :     return true;
     870             : 
     871             : eanbadcheck:
     872          14 :     if (g_weak)
     873             :     {                           /* weak input mode is activated: */
     874             :         /* set the "invalid-check-digit-on-input" flag */
     875           0 :         *result = str2ean(aux1);
     876           0 :         *result |= 1;
     877           0 :         return true;
     878             :     }
     879             : 
     880          14 :     if (!errorOK)
     881             :     {
     882          14 :         if (rcheck == (unsigned) -1)
     883             :         {
     884           0 :             ereport(ERROR,
     885             :                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     886             :                      errmsg("invalid %s number: \"%s\"",
     887             :                             isn_names[accept], str)));
     888             :         }
     889             :         else
     890             :         {
     891          14 :             ereport(ERROR,
     892             :                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     893             :                      errmsg("invalid check digit for %s number: \"%s\", should be %c",
     894             :                             isn_names[accept], str, (rcheck == 10) ? ('X') : (rcheck + '0'))));
     895             :         }
     896             :     }
     897           0 :     return false;
     898             : 
     899             : eaninvalid:
     900           4 :     if (!errorOK)
     901           4 :         ereport(ERROR,
     902             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     903             :                  errmsg("invalid input syntax for %s number: \"%s\"",
     904             :                         isn_names[accept], str)));
     905           0 :     return false;
     906             : 
     907             : eanwrongtype:
     908          36 :     if (!errorOK)
     909          36 :         ereport(ERROR,
     910             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     911             :                  errmsg("cannot cast %s to %s for number: \"%s\"",
     912             :                         isn_names[type], isn_names[accept], str)));
     913           0 :     return false;
     914             : 
     915             : eantoobig:
     916           0 :     if (!errorOK)
     917           0 :         ereport(ERROR,
     918             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
     919             :                  errmsg("value \"%s\" is out of range for %s type",
     920             :                         str, isn_names[accept])));
     921           0 :     return false;
     922             : }
     923             : 
     924             : /*----------------------------------------------------------
     925             :  * Exported routines.
     926             :  *---------------------------------------------------------*/
     927             : 
     928             : void        _PG_init(void);
     929             : 
     930             : void
     931           2 : _PG_init(void)
     932             : {
     933             :     if (ISN_DEBUG)
     934             :     {
     935             :         if (!check_table(EAN13_range, EAN13_index))
     936             :             elog(ERROR, "EAN13 failed check");
     937             :         if (!check_table(ISBN_range, ISBN_index))
     938             :             elog(ERROR, "ISBN failed check");
     939             :         if (!check_table(ISMN_range, ISMN_index))
     940             :             elog(ERROR, "ISMN failed check");
     941             :         if (!check_table(ISSN_range, ISSN_index))
     942             :             elog(ERROR, "ISSN failed check");
     943             :         if (!check_table(UPC_range, UPC_index))
     944             :             elog(ERROR, "UPC failed check");
     945             :     }
     946           2 : }
     947             : 
     948             : /* isn_out
     949             :  */
     950          16 : PG_FUNCTION_INFO_V1(isn_out);
     951             : Datum
     952          30 : isn_out(PG_FUNCTION_ARGS)
     953             : {
     954          30 :     ean13       val = PG_GETARG_EAN13(0);
     955             :     char       *result;
     956             :     char        buf[MAXEAN13LEN + 1];
     957             : 
     958          30 :     (void) ean2string(val, false, buf, true);
     959             : 
     960          30 :     result = pstrdup(buf);
     961          30 :     PG_RETURN_CSTRING(result);
     962             : }
     963             : 
     964             : /* ean13_out
     965             :  */
     966          16 : PG_FUNCTION_INFO_V1(ean13_out);
     967             : Datum
     968          34 : ean13_out(PG_FUNCTION_ARGS)
     969             : {
     970          34 :     ean13       val = PG_GETARG_EAN13(0);
     971             :     char       *result;
     972             :     char        buf[MAXEAN13LEN + 1];
     973             : 
     974          34 :     (void) ean2string(val, false, buf, false);
     975             : 
     976          34 :     result = pstrdup(buf);
     977          34 :     PG_RETURN_CSTRING(result);
     978             : }
     979             : 
     980             : /* ean13_in
     981             :  */
     982           4 : PG_FUNCTION_INFO_V1(ean13_in);
     983             : Datum
     984          34 : ean13_in(PG_FUNCTION_ARGS)
     985             : {
     986          34 :     const char *str = PG_GETARG_CSTRING(0);
     987             :     ean13       result;
     988             : 
     989          34 :     (void) string2ean(str, false, &result, EAN13);
     990          30 :     PG_RETURN_EAN13(result);
     991             : }
     992             : 
     993             : /* isbn_in
     994             :  */
     995           8 : PG_FUNCTION_INFO_V1(isbn_in);
     996             : Datum
     997          38 : isbn_in(PG_FUNCTION_ARGS)
     998             : {
     999          38 :     const char *str = PG_GETARG_CSTRING(0);
    1000             :     ean13       result;
    1001             : 
    1002          38 :     (void) string2ean(str, false, &result, ISBN);
    1003          18 :     PG_RETURN_EAN13(result);
    1004             : }
    1005             : 
    1006             : /* ismn_in
    1007             :  */
    1008           8 : PG_FUNCTION_INFO_V1(ismn_in);
    1009             : Datum
    1010          24 : ismn_in(PG_FUNCTION_ARGS)
    1011             : {
    1012          24 :     const char *str = PG_GETARG_CSTRING(0);
    1013             :     ean13       result;
    1014             : 
    1015          24 :     (void) string2ean(str, false, &result, ISMN);
    1016          14 :     PG_RETURN_EAN13(result);
    1017             : }
    1018             : 
    1019             : /* issn_in
    1020             :  */
    1021           8 : PG_FUNCTION_INFO_V1(issn_in);
    1022             : Datum
    1023          22 : issn_in(PG_FUNCTION_ARGS)
    1024             : {
    1025          22 :     const char *str = PG_GETARG_CSTRING(0);
    1026             :     ean13       result;
    1027             : 
    1028          22 :     (void) string2ean(str, false, &result, ISSN);
    1029          12 :     PG_RETURN_EAN13(result);
    1030             : }
    1031             : 
    1032             : /* upc_in
    1033             :  */
    1034           4 : PG_FUNCTION_INFO_V1(upc_in);
    1035             : Datum
    1036          12 : upc_in(PG_FUNCTION_ARGS)
    1037             : {
    1038          12 :     const char *str = PG_GETARG_CSTRING(0);
    1039             :     ean13       result;
    1040             : 
    1041          12 :     (void) string2ean(str, false, &result, UPC);
    1042           2 :     PG_RETURN_EAN13(result);
    1043             : }
    1044             : 
    1045             : /* casting functions
    1046             : */
    1047           8 : PG_FUNCTION_INFO_V1(isbn_cast_from_ean13);
    1048             : Datum
    1049           6 : isbn_cast_from_ean13(PG_FUNCTION_ARGS)
    1050             : {
    1051           6 :     ean13       val = PG_GETARG_EAN13(0);
    1052             :     ean13       result;
    1053             : 
    1054           6 :     (void) ean2isn(val, false, &result, ISBN);
    1055             : 
    1056           6 :     PG_RETURN_EAN13(result);
    1057             : }
    1058             : 
    1059           6 : PG_FUNCTION_INFO_V1(ismn_cast_from_ean13);
    1060             : Datum
    1061           2 : ismn_cast_from_ean13(PG_FUNCTION_ARGS)
    1062             : {
    1063           2 :     ean13       val = PG_GETARG_EAN13(0);
    1064             :     ean13       result;
    1065             : 
    1066           2 :     (void) ean2isn(val, false, &result, ISMN);
    1067             : 
    1068           2 :     PG_RETURN_EAN13(result);
    1069             : }
    1070             : 
    1071           6 : PG_FUNCTION_INFO_V1(issn_cast_from_ean13);
    1072             : Datum
    1073           2 : issn_cast_from_ean13(PG_FUNCTION_ARGS)
    1074             : {
    1075           2 :     ean13       val = PG_GETARG_EAN13(0);
    1076             :     ean13       result;
    1077             : 
    1078           2 :     (void) ean2isn(val, false, &result, ISSN);
    1079             : 
    1080           2 :     PG_RETURN_EAN13(result);
    1081             : }
    1082             : 
    1083           4 : PG_FUNCTION_INFO_V1(upc_cast_from_ean13);
    1084             : Datum
    1085           2 : upc_cast_from_ean13(PG_FUNCTION_ARGS)
    1086             : {
    1087           2 :     ean13       val = PG_GETARG_EAN13(0);
    1088             :     ean13       result;
    1089             : 
    1090           2 :     (void) ean2isn(val, false, &result, UPC);
    1091             : 
    1092           2 :     PG_RETURN_EAN13(result);
    1093             : }
    1094             : 
    1095             : 
    1096             : /* is_valid - returns false if the "invalid-check-digit-on-input" is set
    1097             :  */
    1098          16 : PG_FUNCTION_INFO_V1(is_valid);
    1099             : Datum
    1100           0 : is_valid(PG_FUNCTION_ARGS)
    1101             : {
    1102           0 :     ean13       val = PG_GETARG_EAN13(0);
    1103             : 
    1104           0 :     PG_RETURN_BOOL((val & 1) == 0);
    1105             : }
    1106             : 
    1107             : /* make_valid - unsets the "invalid-check-digit-on-input" flag
    1108             :  */
    1109          16 : PG_FUNCTION_INFO_V1(make_valid);
    1110             : Datum
    1111           0 : make_valid(PG_FUNCTION_ARGS)
    1112             : {
    1113           0 :     ean13       val = PG_GETARG_EAN13(0);
    1114             : 
    1115           0 :     val &= ~((ean13) 1);
    1116           0 :     PG_RETURN_EAN13(val);
    1117             : }
    1118             : 
    1119             : /* this function temporarily sets weak input flag
    1120             :  * (to lose the strictness of check digit acceptance)
    1121             :  * It's a helper function, not intended to be used!!
    1122             :  */
    1123           2 : PG_FUNCTION_INFO_V1(accept_weak_input);
    1124             : Datum
    1125           0 : accept_weak_input(PG_FUNCTION_ARGS)
    1126             : {
    1127             : #ifdef ISN_WEAK_MODE
    1128           0 :     g_weak = PG_GETARG_BOOL(0);
    1129             : #else
    1130             :     /* function has no effect */
    1131             : #endif                          /* ISN_WEAK_MODE */
    1132           0 :     PG_RETURN_BOOL(g_weak);
    1133             : }
    1134             : 
    1135           2 : PG_FUNCTION_INFO_V1(weak_input_status);
    1136             : Datum
    1137           0 : weak_input_status(PG_FUNCTION_ARGS)
    1138             : {
    1139           0 :     PG_RETURN_BOOL(g_weak);
    1140             : }

Generated by: LCOV version 1.13