PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
regc_pg_locale.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * regc_pg_locale.c
4 * ctype functions adapted to work on pg_wchar (a/k/a chr),
5 * and functions to cache the results of wholesale ctype probing.
6 *
7 * This file is #included by regcomp.c; it's not meant to compile standalone.
8 *
9 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
10 * Portions Copyright (c) 1994, Regents of the University of California
11 *
12 * IDENTIFICATION
13 * src/backend/regex/regc_pg_locale.c
14 *
15 *-------------------------------------------------------------------------
16 */
17
19#include "common/unicode_case.h"
21#include "utils/pg_locale.h"
22
23/*
24 * To provide as much functionality as possible on a variety of platforms,
25 * without going so far as to implement everything from scratch, we use
26 * several implementation strategies depending on the situation:
27 *
28 * 1. In C/POSIX collations, we use hard-wired code. We can't depend on
29 * the <ctype.h> functions since those will obey LC_CTYPE. Note that these
30 * collations don't give a fig about multibyte characters.
31 *
32 * 2. In the "default" collation (which is supposed to obey LC_CTYPE):
33 *
34 * 2a. When working in UTF8 encoding, we use the <wctype.h> functions.
35 * This assumes that every platform uses Unicode codepoints directly
36 * as the wchar_t representation of Unicode. On some platforms
37 * wchar_t is only 16 bits wide, so we have to punt for codepoints > 0xFFFF.
38 *
39 * 2b. In all other encodings, we use the <ctype.h> functions for pg_wchar
40 * values up to 255, and punt for values above that. This is 100% correct
41 * only in single-byte encodings such as LATINn. However, non-Unicode
42 * multibyte encodings are mostly Far Eastern character sets for which the
43 * properties being tested here aren't very relevant for higher code values
44 * anyway. The difficulty with using the <wctype.h> functions with
45 * non-Unicode multibyte encodings is that we can have no certainty that
46 * the platform's wchar_t representation matches what we do in pg_wchar
47 * conversions.
48 *
49 * 3. Here, we use the locale_t-extended forms of the <wctype.h> and <ctype.h>
50 * functions, under exactly the same cases as #2.
51 *
52 * There is one notable difference between cases 2 and 3: in the "default"
53 * collation we force ASCII letters to follow ASCII upcase/downcase rules,
54 * while in a non-default collation we just let the library functions do what
55 * they will. The case where this matters is treatment of I/i in Turkish,
56 * and the behavior is meant to match the upper()/lower() SQL functions.
57 *
58 * We store the active collation setting in static variables. In principle
59 * it could be passed down to here via the regex library's "struct vars" data
60 * structure; but that would require somewhat invasive changes in the regex
61 * library, and right now there's no real benefit to be gained from that.
62 *
63 * NB: the coding here assumes pg_wchar is an unsigned type.
64 */
65
66typedef enum
67{
68 PG_REGEX_STRATEGY_C, /* C locale (encoding independent) */
69 PG_REGEX_STRATEGY_BUILTIN, /* built-in Unicode semantics */
70 PG_REGEX_STRATEGY_LIBC_WIDE, /* Use locale_t <wctype.h> functions */
71 PG_REGEX_STRATEGY_LIBC_1BYTE, /* Use locale_t <ctype.h> functions */
72 PG_REGEX_STRATEGY_ICU, /* Use ICU uchar.h functions */
74
77
78/*
79 * Hard-wired character properties for C locale
80 */
81#define PG_ISDIGIT 0x01
82#define PG_ISALPHA 0x02
83#define PG_ISALNUM (PG_ISDIGIT | PG_ISALPHA)
84#define PG_ISUPPER 0x04
85#define PG_ISLOWER 0x08
86#define PG_ISGRAPH 0x10
87#define PG_ISPRINT 0x20
88#define PG_ISPUNCT 0x40
89#define PG_ISSPACE 0x80
90
91static const unsigned char pg_char_properties[128] = {
92 /* NUL */ 0,
93 /* ^A */ 0,
94 /* ^B */ 0,
95 /* ^C */ 0,
96 /* ^D */ 0,
97 /* ^E */ 0,
98 /* ^F */ 0,
99 /* ^G */ 0,
100 /* ^H */ 0,
101 /* ^I */ PG_ISSPACE,
102 /* ^J */ PG_ISSPACE,
103 /* ^K */ PG_ISSPACE,
104 /* ^L */ PG_ISSPACE,
105 /* ^M */ PG_ISSPACE,
106 /* ^N */ 0,
107 /* ^O */ 0,
108 /* ^P */ 0,
109 /* ^Q */ 0,
110 /* ^R */ 0,
111 /* ^S */ 0,
112 /* ^T */ 0,
113 /* ^U */ 0,
114 /* ^V */ 0,
115 /* ^W */ 0,
116 /* ^X */ 0,
117 /* ^Y */ 0,
118 /* ^Z */ 0,
119 /* ^[ */ 0,
120 /* ^\ */ 0,
121 /* ^] */ 0,
122 /* ^^ */ 0,
123 /* ^_ */ 0,
124 /* */ PG_ISPRINT | PG_ISSPACE,
125 /* ! */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
126 /* " */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
127 /* # */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
128 /* $ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
129 /* % */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
130 /* & */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
131 /* ' */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
132 /* ( */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
133 /* ) */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
134 /* * */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
135 /* + */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
136 /* , */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
137 /* - */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
138 /* . */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
139 /* / */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
140 /* 0 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
141 /* 1 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
142 /* 2 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
143 /* 3 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
144 /* 4 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
145 /* 5 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
146 /* 6 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
147 /* 7 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
148 /* 8 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
149 /* 9 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
150 /* : */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
151 /* ; */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
152 /* < */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
153 /* = */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
154 /* > */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
155 /* ? */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
156 /* @ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
183 /* [ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
184 /* \ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
185 /* ] */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
186 /* ^ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
187 /* _ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
188 /* ` */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
215 /* { */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
216 /* | */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
217 /* } */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
218 /* ~ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
219 /* DEL */ 0
220};
221
222
223/*
224 * pg_set_regex_collation: set collation for these functions to obey
225 *
226 * This is called when beginning compilation or execution of a regexp.
227 * Since there's no need for reentrancy of regexp operations, it's okay
228 * to store the results in static variables.
229 */
230void
232{
234 PG_Locale_Strategy strategy;
235
236 if (!OidIsValid(collation))
237 {
238 /*
239 * This typically means that the parser could not resolve a conflict
240 * of implicit collations, so report it that way.
241 */
243 (errcode(ERRCODE_INDETERMINATE_COLLATION),
244 errmsg("could not determine which collation to use for regular expression"),
245 errhint("Use the COLLATE clause to set the collation explicitly.")));
246 }
247
248 if (collation == C_COLLATION_OID)
249 {
250 /*
251 * Some callers expect regexes to work for C_COLLATION_OID before
252 * catalog access is available, so we can't call
253 * pg_newlocale_from_collation().
254 */
255 strategy = PG_REGEX_STRATEGY_C;
256 locale = 0;
257 }
258 else
259 {
261
262 if (!locale->deterministic)
264 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
265 errmsg("nondeterministic collations are not supported for regular expressions")));
266
267 if (locale->ctype_is_c)
268 {
269 /*
270 * C/POSIX collations use this path regardless of database
271 * encoding
272 */
273 strategy = PG_REGEX_STRATEGY_C;
274 locale = 0;
275 }
276 else if (locale->provider == COLLPROVIDER_BUILTIN)
277 {
279 strategy = PG_REGEX_STRATEGY_BUILTIN;
280 }
281#ifdef USE_ICU
282 else if (locale->provider == COLLPROVIDER_ICU)
283 {
284 strategy = PG_REGEX_STRATEGY_ICU;
285 }
286#endif
287 else
288 {
289 Assert(locale->provider == COLLPROVIDER_LIBC);
292 else
294 }
295 }
296
297 pg_regex_strategy = strategy;
299}
300
301static int
303{
304 switch (pg_regex_strategy)
305 {
307 return (c <= (pg_wchar) 127 &&
310 return pg_u_isdigit(c, true);
312 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
313 return iswdigit_l((wint_t) c, pg_regex_locale->info.lt);
314 /* FALL THRU */
316 return (c <= (pg_wchar) UCHAR_MAX &&
317 isdigit_l((unsigned char) c, pg_regex_locale->info.lt));
318 break;
320#ifdef USE_ICU
321 return u_isdigit(c);
322#endif
323 break;
324 }
325 return 0; /* can't get here, but keep compiler quiet */
326}
327
328static int
330{
331 switch (pg_regex_strategy)
332 {
334 return (c <= (pg_wchar) 127 &&
337 return pg_u_isalpha(c);
339 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
340 return iswalpha_l((wint_t) c, pg_regex_locale->info.lt);
341 /* FALL THRU */
343 return (c <= (pg_wchar) UCHAR_MAX &&
344 isalpha_l((unsigned char) c, pg_regex_locale->info.lt));
345 break;
347#ifdef USE_ICU
348 return u_isalpha(c);
349#endif
350 break;
351 }
352 return 0; /* can't get here, but keep compiler quiet */
353}
354
355static int
357{
358 switch (pg_regex_strategy)
359 {
361 return (c <= (pg_wchar) 127 &&
364 return pg_u_isalnum(c, true);
366 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
367 return iswalnum_l((wint_t) c, pg_regex_locale->info.lt);
368 /* FALL THRU */
370 return (c <= (pg_wchar) UCHAR_MAX &&
371 isalnum_l((unsigned char) c, pg_regex_locale->info.lt));
372 break;
374#ifdef USE_ICU
375 return u_isalnum(c);
376#endif
377 break;
378 }
379 return 0; /* can't get here, but keep compiler quiet */
380}
381
382static int
384{
385 /* We define word characters as alnum class plus underscore */
386 if (c == CHR('_'))
387 return 1;
388 return pg_wc_isalnum(c);
389}
390
391static int
393{
394 switch (pg_regex_strategy)
395 {
397 return (c <= (pg_wchar) 127 &&
400 return pg_u_isupper(c);
402 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
403 return iswupper_l((wint_t) c, pg_regex_locale->info.lt);
404 /* FALL THRU */
406 return (c <= (pg_wchar) UCHAR_MAX &&
407 isupper_l((unsigned char) c, pg_regex_locale->info.lt));
408 break;
410#ifdef USE_ICU
411 return u_isupper(c);
412#endif
413 break;
414 }
415 return 0; /* can't get here, but keep compiler quiet */
416}
417
418static int
420{
421 switch (pg_regex_strategy)
422 {
424 return (c <= (pg_wchar) 127 &&
427 return pg_u_islower(c);
429 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
430 return iswlower_l((wint_t) c, pg_regex_locale->info.lt);
431 /* FALL THRU */
433 return (c <= (pg_wchar) UCHAR_MAX &&
434 islower_l((unsigned char) c, pg_regex_locale->info.lt));
435 break;
437#ifdef USE_ICU
438 return u_islower(c);
439#endif
440 break;
441 }
442 return 0; /* can't get here, but keep compiler quiet */
443}
444
445static int
447{
448 switch (pg_regex_strategy)
449 {
451 return (c <= (pg_wchar) 127 &&
454 return pg_u_isgraph(c);
456 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
457 return iswgraph_l((wint_t) c, pg_regex_locale->info.lt);
458 /* FALL THRU */
460 return (c <= (pg_wchar) UCHAR_MAX &&
461 isgraph_l((unsigned char) c, pg_regex_locale->info.lt));
462 break;
464#ifdef USE_ICU
465 return u_isgraph(c);
466#endif
467 break;
468 }
469 return 0; /* can't get here, but keep compiler quiet */
470}
471
472static int
474{
475 switch (pg_regex_strategy)
476 {
478 return (c <= (pg_wchar) 127 &&
481 return pg_u_isprint(c);
483 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
484 return iswprint_l((wint_t) c, pg_regex_locale->info.lt);
485 /* FALL THRU */
487 return (c <= (pg_wchar) UCHAR_MAX &&
488 isprint_l((unsigned char) c, pg_regex_locale->info.lt));
489 break;
491#ifdef USE_ICU
492 return u_isprint(c);
493#endif
494 break;
495 }
496 return 0; /* can't get here, but keep compiler quiet */
497}
498
499static int
501{
502 switch (pg_regex_strategy)
503 {
505 return (c <= (pg_wchar) 127 &&
508 return pg_u_ispunct(c, true);
510 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
511 return iswpunct_l((wint_t) c, pg_regex_locale->info.lt);
512 /* FALL THRU */
514 return (c <= (pg_wchar) UCHAR_MAX &&
515 ispunct_l((unsigned char) c, pg_regex_locale->info.lt));
516 break;
518#ifdef USE_ICU
519 return u_ispunct(c);
520#endif
521 break;
522 }
523 return 0; /* can't get here, but keep compiler quiet */
524}
525
526static int
528{
529 switch (pg_regex_strategy)
530 {
532 return (c <= (pg_wchar) 127 &&
535 return pg_u_isspace(c);
537 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
538 return iswspace_l((wint_t) c, pg_regex_locale->info.lt);
539 /* FALL THRU */
541 return (c <= (pg_wchar) UCHAR_MAX &&
542 isspace_l((unsigned char) c, pg_regex_locale->info.lt));
543 break;
545#ifdef USE_ICU
546 return u_isspace(c);
547#endif
548 break;
549 }
550 return 0; /* can't get here, but keep compiler quiet */
551}
552
553static pg_wchar
555{
556 switch (pg_regex_strategy)
557 {
559 if (c <= (pg_wchar) 127)
560 return pg_ascii_toupper((unsigned char) c);
561 return c;
565 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
566 return towupper_l((wint_t) c, pg_regex_locale->info.lt);
567 /* FALL THRU */
569 if (c <= (pg_wchar) UCHAR_MAX)
570 return toupper_l((unsigned char) c, pg_regex_locale->info.lt);
571 return c;
573#ifdef USE_ICU
574 return u_toupper(c);
575#endif
576 break;
577 }
578 return 0; /* can't get here, but keep compiler quiet */
579}
580
581static pg_wchar
583{
584 switch (pg_regex_strategy)
585 {
587 if (c <= (pg_wchar) 127)
588 return pg_ascii_tolower((unsigned char) c);
589 return c;
593 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
594 return towlower_l((wint_t) c, pg_regex_locale->info.lt);
595 /* FALL THRU */
597 if (c <= (pg_wchar) UCHAR_MAX)
598 return tolower_l((unsigned char) c, pg_regex_locale->info.lt);
599 return c;
601#ifdef USE_ICU
602 return u_tolower(c);
603#endif
604 break;
605 }
606 return 0; /* can't get here, but keep compiler quiet */
607}
608
609
610/*
611 * These functions cache the results of probing libc's ctype behavior for
612 * all character codes of interest in a given encoding/collation. The
613 * result is provided as a "struct cvec", but notice that the representation
614 * is a touch different from a cvec created by regc_cvec.c: we allocate the
615 * chrs[] and ranges[] arrays separately from the struct so that we can
616 * realloc them larger at need. This is okay since the cvecs made here
617 * should never be freed by freecvec().
618 *
619 * We use malloc not palloc since we mustn't lose control on out-of-memory;
620 * the main regex code expects us to return a failure indication instead.
621 */
622
623typedef int (*pg_wc_probefunc) (pg_wchar c);
624
625typedef struct pg_ctype_cache
626{
627 pg_wc_probefunc probefunc; /* pg_wc_isalpha or a sibling */
628 pg_locale_t locale; /* locale this entry is for */
629 struct cvec cv; /* cache entry contents */
630 struct pg_ctype_cache *next; /* chain link */
632
634
635/*
636 * Add a chr or range to pcc->cv; return false if run out of memory
637 */
638static bool
639store_match(pg_ctype_cache *pcc, pg_wchar chr1, int nchrs)
640{
641 chr *newchrs;
642
643 if (nchrs > 1)
644 {
645 if (pcc->cv.nranges >= pcc->cv.rangespace)
646 {
647 pcc->cv.rangespace *= 2;
648 newchrs = (chr *) realloc(pcc->cv.ranges,
649 pcc->cv.rangespace * sizeof(chr) * 2);
650 if (newchrs == NULL)
651 return false;
652 pcc->cv.ranges = newchrs;
653 }
654 pcc->cv.ranges[pcc->cv.nranges * 2] = chr1;
655 pcc->cv.ranges[pcc->cv.nranges * 2 + 1] = chr1 + nchrs - 1;
656 pcc->cv.nranges++;
657 }
658 else
659 {
660 assert(nchrs == 1);
661 if (pcc->cv.nchrs >= pcc->cv.chrspace)
662 {
663 pcc->cv.chrspace *= 2;
664 newchrs = (chr *) realloc(pcc->cv.chrs,
665 pcc->cv.chrspace * sizeof(chr));
666 if (newchrs == NULL)
667 return false;
668 pcc->cv.chrs = newchrs;
669 }
670 pcc->cv.chrs[pcc->cv.nchrs++] = chr1;
671 }
672 return true;
673}
674
675/*
676 * Given a probe function (e.g., pg_wc_isalpha) get a struct cvec for all
677 * chrs satisfying the probe function. The active collation is the one
678 * previously set by pg_set_regex_collation. Return NULL if out of memory.
679 *
680 * Note that the result must not be freed or modified by caller.
681 */
682static struct cvec *
684{
685 pg_ctype_cache *pcc;
686 pg_wchar max_chr;
687 pg_wchar cur_chr;
688 int nmatches;
689 chr *newchrs;
690
691 /*
692 * Do we already have the answer cached?
693 */
694 for (pcc = pg_ctype_cache_list; pcc != NULL; pcc = pcc->next)
695 {
696 if (pcc->probefunc == probefunc &&
697 pcc->locale == pg_regex_locale)
698 return &pcc->cv;
699 }
700
701 /*
702 * Nope, so initialize some workspace ...
703 */
704 pcc = (pg_ctype_cache *) malloc(sizeof(pg_ctype_cache));
705 if (pcc == NULL)
706 return NULL;
707 pcc->probefunc = probefunc;
708 pcc->locale = pg_regex_locale;
709 pcc->cv.nchrs = 0;
710 pcc->cv.chrspace = 128;
711 pcc->cv.chrs = (chr *) malloc(pcc->cv.chrspace * sizeof(chr));
712 pcc->cv.nranges = 0;
713 pcc->cv.rangespace = 64;
714 pcc->cv.ranges = (chr *) malloc(pcc->cv.rangespace * sizeof(chr) * 2);
715 if (pcc->cv.chrs == NULL || pcc->cv.ranges == NULL)
716 goto out_of_memory;
717 pcc->cv.cclasscode = cclasscode;
718
719 /*
720 * Decide how many character codes we ought to look through. In general
721 * we don't go past MAX_SIMPLE_CHR; chr codes above that are handled at
722 * runtime using the "high colormap" mechanism. However, in C locale
723 * there's no need to go further than 127, and if we only have a 1-byte
724 * <ctype.h> API there's no need to go further than that can handle.
725 *
726 * If it's not MAX_SIMPLE_CHR that's constraining the search, mark the
727 * output cvec as not having any locale-dependent behavior, since there
728 * will be no need to do any run-time locale checks. (The #if's here
729 * would always be true for production values of MAX_SIMPLE_CHR, but it's
730 * useful to allow it to be small for testing purposes.)
731 */
732 switch (pg_regex_strategy)
733 {
735#if MAX_SIMPLE_CHR >= 127
736 max_chr = (pg_wchar) 127;
737 pcc->cv.cclasscode = -1;
738#else
739 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
740#endif
741 break;
743 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
744 break;
746 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
747 break;
749#if MAX_SIMPLE_CHR >= UCHAR_MAX
750 max_chr = (pg_wchar) UCHAR_MAX;
751 pcc->cv.cclasscode = -1;
752#else
753 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
754#endif
755 break;
757 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
758 break;
759 default:
760 Assert(false);
761 max_chr = 0; /* can't get here, but keep compiler quiet */
762 break;
763 }
764
765 /*
766 * And scan 'em ...
767 */
768 nmatches = 0; /* number of consecutive matches */
769
770 for (cur_chr = 0; cur_chr <= max_chr; cur_chr++)
771 {
772 if ((*probefunc) (cur_chr))
773 nmatches++;
774 else if (nmatches > 0)
775 {
776 if (!store_match(pcc, cur_chr - nmatches, nmatches))
777 goto out_of_memory;
778 nmatches = 0;
779 }
780 }
781
782 if (nmatches > 0)
783 if (!store_match(pcc, cur_chr - nmatches, nmatches))
784 goto out_of_memory;
785
786 /*
787 * We might have allocated more memory than needed, if so free it
788 */
789 if (pcc->cv.nchrs == 0)
790 {
791 free(pcc->cv.chrs);
792 pcc->cv.chrs = NULL;
793 pcc->cv.chrspace = 0;
794 }
795 else if (pcc->cv.nchrs < pcc->cv.chrspace)
796 {
797 newchrs = (chr *) realloc(pcc->cv.chrs,
798 pcc->cv.nchrs * sizeof(chr));
799 if (newchrs == NULL)
800 goto out_of_memory;
801 pcc->cv.chrs = newchrs;
802 pcc->cv.chrspace = pcc->cv.nchrs;
803 }
804 if (pcc->cv.nranges == 0)
805 {
806 free(pcc->cv.ranges);
807 pcc->cv.ranges = NULL;
808 pcc->cv.rangespace = 0;
809 }
810 else if (pcc->cv.nranges < pcc->cv.rangespace)
811 {
812 newchrs = (chr *) realloc(pcc->cv.ranges,
813 pcc->cv.nranges * sizeof(chr) * 2);
814 if (newchrs == NULL)
815 goto out_of_memory;
816 pcc->cv.ranges = newchrs;
817 pcc->cv.rangespace = pcc->cv.nranges;
818 }
819
820 /*
821 * Success, link it into cache chain
822 */
825
826 return &pcc->cv;
827
828 /*
829 * Failure, clean up
830 */
831out_of_memory:
832 free(pcc->cv.chrs);
833 free(pcc->cv.ranges);
834 free(pcc);
835
836 return NULL;
837}
#define Assert(condition)
Definition: c.h:812
#define OidIsValid(objectId)
Definition: c.h:729
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
#define realloc(a, b)
Definition: header.h:60
#define free(a)
Definition: header.h:65
#define malloc(a)
Definition: header.h:50
static char * locale
Definition: initdb.c:140
unsigned int pg_wchar
Definition: mbprint.c:31
int GetDatabaseEncoding(void)
Definition: mbutils.c:1261
pg_locale_t pg_newlocale_from_collation(Oid collid)
Definition: pg_locale.c:1328
@ PG_UTF8
Definition: pg_wchar.h:232
unsigned char pg_ascii_tolower(unsigned char ch)
Definition: pgstrcasecmp.c:146
unsigned char pg_ascii_toupper(unsigned char ch)
Definition: pgstrcasecmp.c:135
unsigned int Oid
Definition: postgres_ext.h:31
char * c
static int pg_wc_islower(pg_wchar c)
static int pg_wc_isword(pg_wchar c)
static int pg_wc_isspace(pg_wchar c)
static pg_wchar pg_wc_tolower(pg_wchar c)
#define PG_ISLOWER
#define PG_ISPRINT
static int pg_wc_ispunct(pg_wchar c)
#define PG_ISALPHA
static pg_ctype_cache * pg_ctype_cache_list
static int pg_wc_isgraph(pg_wchar c)
#define PG_ISGRAPH
static pg_wchar pg_wc_toupper(pg_wchar c)
#define PG_ISPUNCT
static bool store_match(pg_ctype_cache *pcc, pg_wchar chr1, int nchrs)
static int pg_wc_isprint(pg_wchar c)
#define PG_ISDIGIT
#define PG_ISUPPER
static int pg_wc_isalnum(pg_wchar c)
int(* pg_wc_probefunc)(pg_wchar c)
static int pg_wc_isdigit(pg_wchar c)
static PG_Locale_Strategy pg_regex_strategy
#define PG_ISALNUM
PG_Locale_Strategy
@ PG_REGEX_STRATEGY_C
@ PG_REGEX_STRATEGY_LIBC_WIDE
@ PG_REGEX_STRATEGY_ICU
@ PG_REGEX_STRATEGY_BUILTIN
@ PG_REGEX_STRATEGY_LIBC_1BYTE
#define PG_ISSPACE
void pg_set_regex_collation(Oid collation)
static struct cvec * pg_ctype_get_cache(pg_wc_probefunc probefunc, int cclasscode)
static pg_locale_t pg_regex_locale
static int pg_wc_isupper(pg_wchar c)
static int pg_wc_isalpha(pg_wchar c)
static const unsigned char pg_char_properties[128]
struct pg_ctype_cache pg_ctype_cache
#define MAX_SIMPLE_CHR
Definition: regcustom.h:87
pg_wchar chr
Definition: regcustom.h:59
#define CHR(c)
Definition: regcustom.h:62
#define assert(x)
Definition: regcustom.h:56
Definition: regguts.h:279
int chrspace
Definition: regguts.h:281
int nchrs
Definition: regguts.h:280
int rangespace
Definition: regguts.h:284
chr * chrs
Definition: regguts.h:282
chr * ranges
Definition: regguts.h:285
int cclasscode
Definition: regguts.h:286
int nranges
Definition: regguts.h:283
pg_wc_probefunc probefunc
struct pg_ctype_cache * next
pg_locale_t locale
struct cvec cv
union pg_locale_struct::@157 info
pg_wchar unicode_uppercase_simple(pg_wchar code)
Definition: unicode_case.c:44
pg_wchar unicode_lowercase_simple(pg_wchar code)
Definition: unicode_case.c:28
bool pg_u_isspace(pg_wchar code)
bool pg_u_ispunct(pg_wchar code, bool posix)
bool pg_u_isprint(pg_wchar code)
bool pg_u_islower(pg_wchar code)
bool pg_u_isalpha(pg_wchar code)
bool pg_u_isalnum(pg_wchar code, bool posix)
bool pg_u_isupper(pg_wchar code)
bool pg_u_isdigit(pg_wchar code, bool posix)
bool pg_u_isgraph(pg_wchar code)
#define toupper_l
Definition: win32_port.h:444
#define iswalnum_l
Definition: win32_port.h:452
#define isgraph_l
Definition: win32_port.h:457
#define towupper_l
Definition: win32_port.h:446
#define ispunct_l
Definition: win32_port.h:461
#define isalpha_l
Definition: win32_port.h:449
#define iswgraph_l
Definition: win32_port.h:458
#define towlower_l
Definition: win32_port.h:445
#define iswspace_l
Definition: win32_port.h:464
#define isdigit_l
Definition: win32_port.h:447
#define tolower_l
Definition: win32_port.h:443
#define iswupper_l
Definition: win32_port.h:454
#define iswalpha_l
Definition: win32_port.h:450
#define isprint_l
Definition: win32_port.h:459
#define iswprint_l
Definition: win32_port.h:460
#define isupper_l
Definition: win32_port.h:453
#define isalnum_l
Definition: win32_port.h:451
#define islower_l
Definition: win32_port.h:455
#define iswlower_l
Definition: win32_port.h:456
#define iswpunct_l
Definition: win32_port.h:462
#define isspace_l
Definition: win32_port.h:463
#define iswdigit_l
Definition: win32_port.h:448