PostgreSQL Source Code: contrib/isn/isn.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /