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-2024, 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 
18 #include "catalog/pg_collation.h"
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 
66 typedef 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 
78 
79 /*
80  * Hard-wired character properties for C locale
81  */
82 #define PG_ISDIGIT 0x01
83 #define PG_ISALPHA 0x02
84 #define PG_ISALNUM (PG_ISDIGIT | PG_ISALPHA)
85 #define PG_ISUPPER 0x04
86 #define PG_ISLOWER 0x08
87 #define PG_ISGRAPH 0x10
88 #define PG_ISPRINT 0x20
89 #define PG_ISPUNCT 0x40
90 #define PG_ISSPACE 0x80
91 
92 static const unsigned char pg_char_properties[128] = {
93  /* NUL */ 0,
94  /* ^A */ 0,
95  /* ^B */ 0,
96  /* ^C */ 0,
97  /* ^D */ 0,
98  /* ^E */ 0,
99  /* ^F */ 0,
100  /* ^G */ 0,
101  /* ^H */ 0,
102  /* ^I */ PG_ISSPACE,
103  /* ^J */ PG_ISSPACE,
104  /* ^K */ PG_ISSPACE,
105  /* ^L */ PG_ISSPACE,
106  /* ^M */ PG_ISSPACE,
107  /* ^N */ 0,
108  /* ^O */ 0,
109  /* ^P */ 0,
110  /* ^Q */ 0,
111  /* ^R */ 0,
112  /* ^S */ 0,
113  /* ^T */ 0,
114  /* ^U */ 0,
115  /* ^V */ 0,
116  /* ^W */ 0,
117  /* ^X */ 0,
118  /* ^Y */ 0,
119  /* ^Z */ 0,
120  /* ^[ */ 0,
121  /* ^\ */ 0,
122  /* ^] */ 0,
123  /* ^^ */ 0,
124  /* ^_ */ 0,
125  /* */ PG_ISPRINT | PG_ISSPACE,
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  /* / */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
141  /* 0 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
142  /* 1 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
143  /* 2 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
144  /* 3 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
145  /* 4 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
146  /* 5 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
147  /* 6 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
148  /* 7 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
149  /* 8 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
150  /* 9 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
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,
157  /* @ */ 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,
189  /* ` */ 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  /* ~ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
220  /* DEL */ 0
221 };
222 
223 
224 /*
225  * pg_set_regex_collation: set collation for these functions to obey
226  *
227  * This is called when beginning compilation or execution of a regexp.
228  * Since there's no need for reentrancy of regexp operations, it's okay
229  * to store the results in static variables.
230  */
231 void
233 {
234  pg_locale_t locale = 0;
235  PG_Locale_Strategy strategy;
236 
237  if (!OidIsValid(collation))
238  {
239  /*
240  * This typically means that the parser could not resolve a conflict
241  * of implicit collations, so report it that way.
242  */
243  ereport(ERROR,
244  (errcode(ERRCODE_INDETERMINATE_COLLATION),
245  errmsg("could not determine which collation to use for regular expression"),
246  errhint("Use the COLLATE clause to set the collation explicitly.")));
247  }
248 
249  if (collation == C_COLLATION_OID)
250  {
251  /*
252  * Some callers expect regexes to work for C_COLLATION_OID before
253  * catalog access is available, so we can't call
254  * pg_newlocale_from_collation().
255  */
256  strategy = PG_REGEX_STRATEGY_C;
257  collation = C_COLLATION_OID;
258  }
259  else
260  {
261  locale = pg_newlocale_from_collation(collation);
262 
263  if (!locale->deterministic)
264  ereport(ERROR,
265  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
266  errmsg("nondeterministic collations are not supported for regular expressions")));
267 
268  if (locale->ctype_is_c)
269  {
270  /*
271  * C/POSIX collations use this path regardless of database
272  * encoding
273  */
274  strategy = PG_REGEX_STRATEGY_C;
275  locale = 0;
276  collation = C_COLLATION_OID;
277  }
278  else if (locale->provider == COLLPROVIDER_BUILTIN)
279  {
281  strategy = PG_REGEX_STRATEGY_BUILTIN;
282  }
283 #ifdef USE_ICU
284  else if (locale->provider == COLLPROVIDER_ICU)
285  {
286  strategy = PG_REGEX_STRATEGY_ICU;
287  }
288 #endif
289  else
290  {
291  Assert(locale->provider == COLLPROVIDER_LIBC);
292  if (GetDatabaseEncoding() == PG_UTF8)
293  strategy = PG_REGEX_STRATEGY_LIBC_WIDE;
294  else
295  strategy = PG_REGEX_STRATEGY_LIBC_1BYTE;
296  }
297  }
298 
299  pg_regex_strategy = strategy;
301  pg_regex_collation = collation;
302 }
303 
304 static int
306 {
307  switch (pg_regex_strategy)
308  {
309  case PG_REGEX_STRATEGY_C:
310  return (c <= (pg_wchar) 127 &&
313  return pg_u_isdigit(c, true);
315  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
316  return iswdigit_l((wint_t) c, pg_regex_locale->info.lt);
317  /* FALL THRU */
319  return (c <= (pg_wchar) UCHAR_MAX &&
320  isdigit_l((unsigned char) c, pg_regex_locale->info.lt));
321  break;
323 #ifdef USE_ICU
324  return u_isdigit(c);
325 #endif
326  break;
327  }
328  return 0; /* can't get here, but keep compiler quiet */
329 }
330 
331 static int
333 {
334  switch (pg_regex_strategy)
335  {
336  case PG_REGEX_STRATEGY_C:
337  return (c <= (pg_wchar) 127 &&
340  return pg_u_isalpha(c);
342  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
343  return iswalpha_l((wint_t) c, pg_regex_locale->info.lt);
344  /* FALL THRU */
346  return (c <= (pg_wchar) UCHAR_MAX &&
347  isalpha_l((unsigned char) c, pg_regex_locale->info.lt));
348  break;
350 #ifdef USE_ICU
351  return u_isalpha(c);
352 #endif
353  break;
354  }
355  return 0; /* can't get here, but keep compiler quiet */
356 }
357 
358 static int
360 {
361  switch (pg_regex_strategy)
362  {
363  case PG_REGEX_STRATEGY_C:
364  return (c <= (pg_wchar) 127 &&
367  return pg_u_isalnum(c, true);
369  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
370  return iswalnum_l((wint_t) c, pg_regex_locale->info.lt);
371  /* FALL THRU */
373  return (c <= (pg_wchar) UCHAR_MAX &&
374  isalnum_l((unsigned char) c, pg_regex_locale->info.lt));
375  break;
377 #ifdef USE_ICU
378  return u_isalnum(c);
379 #endif
380  break;
381  }
382  return 0; /* can't get here, but keep compiler quiet */
383 }
384 
385 static int
387 {
388  /* We define word characters as alnum class plus underscore */
389  if (c == CHR('_'))
390  return 1;
391  return pg_wc_isalnum(c);
392 }
393 
394 static int
396 {
397  switch (pg_regex_strategy)
398  {
399  case PG_REGEX_STRATEGY_C:
400  return (c <= (pg_wchar) 127 &&
403  return pg_u_isupper(c);
405  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
406  return iswupper_l((wint_t) c, pg_regex_locale->info.lt);
407  /* FALL THRU */
409  return (c <= (pg_wchar) UCHAR_MAX &&
410  isupper_l((unsigned char) c, pg_regex_locale->info.lt));
411  break;
413 #ifdef USE_ICU
414  return u_isupper(c);
415 #endif
416  break;
417  }
418  return 0; /* can't get here, but keep compiler quiet */
419 }
420 
421 static int
423 {
424  switch (pg_regex_strategy)
425  {
426  case PG_REGEX_STRATEGY_C:
427  return (c <= (pg_wchar) 127 &&
430  return pg_u_islower(c);
432  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
433  return iswlower_l((wint_t) c, pg_regex_locale->info.lt);
434  /* FALL THRU */
436  return (c <= (pg_wchar) UCHAR_MAX &&
437  islower_l((unsigned char) c, pg_regex_locale->info.lt));
438  break;
440 #ifdef USE_ICU
441  return u_islower(c);
442 #endif
443  break;
444  }
445  return 0; /* can't get here, but keep compiler quiet */
446 }
447 
448 static int
450 {
451  switch (pg_regex_strategy)
452  {
453  case PG_REGEX_STRATEGY_C:
454  return (c <= (pg_wchar) 127 &&
457  return pg_u_isgraph(c);
459  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
460  return iswgraph_l((wint_t) c, pg_regex_locale->info.lt);
461  /* FALL THRU */
463  return (c <= (pg_wchar) UCHAR_MAX &&
464  isgraph_l((unsigned char) c, pg_regex_locale->info.lt));
465  break;
467 #ifdef USE_ICU
468  return u_isgraph(c);
469 #endif
470  break;
471  }
472  return 0; /* can't get here, but keep compiler quiet */
473 }
474 
475 static int
477 {
478  switch (pg_regex_strategy)
479  {
480  case PG_REGEX_STRATEGY_C:
481  return (c <= (pg_wchar) 127 &&
484  return pg_u_isprint(c);
486  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
487  return iswprint_l((wint_t) c, pg_regex_locale->info.lt);
488  /* FALL THRU */
490  return (c <= (pg_wchar) UCHAR_MAX &&
491  isprint_l((unsigned char) c, pg_regex_locale->info.lt));
492  break;
494 #ifdef USE_ICU
495  return u_isprint(c);
496 #endif
497  break;
498  }
499  return 0; /* can't get here, but keep compiler quiet */
500 }
501 
502 static int
504 {
505  switch (pg_regex_strategy)
506  {
507  case PG_REGEX_STRATEGY_C:
508  return (c <= (pg_wchar) 127 &&
511  return pg_u_ispunct(c, true);
513  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
514  return iswpunct_l((wint_t) c, pg_regex_locale->info.lt);
515  /* FALL THRU */
517  return (c <= (pg_wchar) UCHAR_MAX &&
518  ispunct_l((unsigned char) c, pg_regex_locale->info.lt));
519  break;
521 #ifdef USE_ICU
522  return u_ispunct(c);
523 #endif
524  break;
525  }
526  return 0; /* can't get here, but keep compiler quiet */
527 }
528 
529 static int
531 {
532  switch (pg_regex_strategy)
533  {
534  case PG_REGEX_STRATEGY_C:
535  return (c <= (pg_wchar) 127 &&
538  return pg_u_isspace(c);
540  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
541  return iswspace_l((wint_t) c, pg_regex_locale->info.lt);
542  /* FALL THRU */
544  return (c <= (pg_wchar) UCHAR_MAX &&
545  isspace_l((unsigned char) c, pg_regex_locale->info.lt));
546  break;
548 #ifdef USE_ICU
549  return u_isspace(c);
550 #endif
551  break;
552  }
553  return 0; /* can't get here, but keep compiler quiet */
554 }
555 
556 static pg_wchar
558 {
559  switch (pg_regex_strategy)
560  {
561  case PG_REGEX_STRATEGY_C:
562  if (c <= (pg_wchar) 127)
563  return pg_ascii_toupper((unsigned char) c);
564  return c;
566  return unicode_uppercase_simple(c);
568  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
569  return towupper_l((wint_t) c, pg_regex_locale->info.lt);
570  /* FALL THRU */
572  if (c <= (pg_wchar) UCHAR_MAX)
573  return toupper_l((unsigned char) c, pg_regex_locale->info.lt);
574  return c;
576 #ifdef USE_ICU
577  return u_toupper(c);
578 #endif
579  break;
580  }
581  return 0; /* can't get here, but keep compiler quiet */
582 }
583 
584 static pg_wchar
586 {
587  switch (pg_regex_strategy)
588  {
589  case PG_REGEX_STRATEGY_C:
590  if (c <= (pg_wchar) 127)
591  return pg_ascii_tolower((unsigned char) c);
592  return c;
594  return unicode_lowercase_simple(c);
596  if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
597  return towlower_l((wint_t) c, pg_regex_locale->info.lt);
598  /* FALL THRU */
600  if (c <= (pg_wchar) UCHAR_MAX)
601  return tolower_l((unsigned char) c, pg_regex_locale->info.lt);
602  return c;
604 #ifdef USE_ICU
605  return u_tolower(c);
606 #endif
607  break;
608  }
609  return 0; /* can't get here, but keep compiler quiet */
610 }
611 
612 
613 /*
614  * These functions cache the results of probing libc's ctype behavior for
615  * all character codes of interest in a given encoding/collation. The
616  * result is provided as a "struct cvec", but notice that the representation
617  * is a touch different from a cvec created by regc_cvec.c: we allocate the
618  * chrs[] and ranges[] arrays separately from the struct so that we can
619  * realloc them larger at need. This is okay since the cvecs made here
620  * should never be freed by freecvec().
621  *
622  * We use malloc not palloc since we mustn't lose control on out-of-memory;
623  * the main regex code expects us to return a failure indication instead.
624  */
625 
626 typedef int (*pg_wc_probefunc) (pg_wchar c);
627 
628 typedef struct pg_ctype_cache
629 {
630  pg_wc_probefunc probefunc; /* pg_wc_isalpha or a sibling */
631  Oid collation; /* collation this entry is for */
632  struct cvec cv; /* cache entry contents */
633  struct pg_ctype_cache *next; /* chain link */
635 
637 
638 /*
639  * Add a chr or range to pcc->cv; return false if run out of memory
640  */
641 static bool
642 store_match(pg_ctype_cache *pcc, pg_wchar chr1, int nchrs)
643 {
644  chr *newchrs;
645 
646  if (nchrs > 1)
647  {
648  if (pcc->cv.nranges >= pcc->cv.rangespace)
649  {
650  pcc->cv.rangespace *= 2;
651  newchrs = (chr *) realloc(pcc->cv.ranges,
652  pcc->cv.rangespace * sizeof(chr) * 2);
653  if (newchrs == NULL)
654  return false;
655  pcc->cv.ranges = newchrs;
656  }
657  pcc->cv.ranges[pcc->cv.nranges * 2] = chr1;
658  pcc->cv.ranges[pcc->cv.nranges * 2 + 1] = chr1 + nchrs - 1;
659  pcc->cv.nranges++;
660  }
661  else
662  {
663  assert(nchrs == 1);
664  if (pcc->cv.nchrs >= pcc->cv.chrspace)
665  {
666  pcc->cv.chrspace *= 2;
667  newchrs = (chr *) realloc(pcc->cv.chrs,
668  pcc->cv.chrspace * sizeof(chr));
669  if (newchrs == NULL)
670  return false;
671  pcc->cv.chrs = newchrs;
672  }
673  pcc->cv.chrs[pcc->cv.nchrs++] = chr1;
674  }
675  return true;
676 }
677 
678 /*
679  * Given a probe function (e.g., pg_wc_isalpha) get a struct cvec for all
680  * chrs satisfying the probe function. The active collation is the one
681  * previously set by pg_set_regex_collation. Return NULL if out of memory.
682  *
683  * Note that the result must not be freed or modified by caller.
684  */
685 static struct cvec *
687 {
688  pg_ctype_cache *pcc;
689  pg_wchar max_chr;
690  pg_wchar cur_chr;
691  int nmatches;
692  chr *newchrs;
693 
694  /*
695  * Do we already have the answer cached?
696  */
697  for (pcc = pg_ctype_cache_list; pcc != NULL; pcc = pcc->next)
698  {
699  if (pcc->probefunc == probefunc &&
701  return &pcc->cv;
702  }
703 
704  /*
705  * Nope, so initialize some workspace ...
706  */
707  pcc = (pg_ctype_cache *) malloc(sizeof(pg_ctype_cache));
708  if (pcc == NULL)
709  return NULL;
710  pcc->probefunc = probefunc;
712  pcc->cv.nchrs = 0;
713  pcc->cv.chrspace = 128;
714  pcc->cv.chrs = (chr *) malloc(pcc->cv.chrspace * sizeof(chr));
715  pcc->cv.nranges = 0;
716  pcc->cv.rangespace = 64;
717  pcc->cv.ranges = (chr *) malloc(pcc->cv.rangespace * sizeof(chr) * 2);
718  if (pcc->cv.chrs == NULL || pcc->cv.ranges == NULL)
719  goto out_of_memory;
720  pcc->cv.cclasscode = cclasscode;
721 
722  /*
723  * Decide how many character codes we ought to look through. In general
724  * we don't go past MAX_SIMPLE_CHR; chr codes above that are handled at
725  * runtime using the "high colormap" mechanism. However, in C locale
726  * there's no need to go further than 127, and if we only have a 1-byte
727  * <ctype.h> API there's no need to go further than that can handle.
728  *
729  * If it's not MAX_SIMPLE_CHR that's constraining the search, mark the
730  * output cvec as not having any locale-dependent behavior, since there
731  * will be no need to do any run-time locale checks. (The #if's here
732  * would always be true for production values of MAX_SIMPLE_CHR, but it's
733  * useful to allow it to be small for testing purposes.)
734  */
735  switch (pg_regex_strategy)
736  {
737  case PG_REGEX_STRATEGY_C:
738 #if MAX_SIMPLE_CHR >= 127
739  max_chr = (pg_wchar) 127;
740  pcc->cv.cclasscode = -1;
741 #else
742  max_chr = (pg_wchar) MAX_SIMPLE_CHR;
743 #endif
744  break;
746  max_chr = (pg_wchar) MAX_SIMPLE_CHR;
747  break;
749  max_chr = (pg_wchar) MAX_SIMPLE_CHR;
750  break;
752 #if MAX_SIMPLE_CHR >= UCHAR_MAX
753  max_chr = (pg_wchar) UCHAR_MAX;
754  pcc->cv.cclasscode = -1;
755 #else
756  max_chr = (pg_wchar) MAX_SIMPLE_CHR;
757 #endif
758  break;
760  max_chr = (pg_wchar) MAX_SIMPLE_CHR;
761  break;
762  default:
763  Assert(false);
764  max_chr = 0; /* can't get here, but keep compiler quiet */
765  break;
766  }
767 
768  /*
769  * And scan 'em ...
770  */
771  nmatches = 0; /* number of consecutive matches */
772 
773  for (cur_chr = 0; cur_chr <= max_chr; cur_chr++)
774  {
775  if ((*probefunc) (cur_chr))
776  nmatches++;
777  else if (nmatches > 0)
778  {
779  if (!store_match(pcc, cur_chr - nmatches, nmatches))
780  goto out_of_memory;
781  nmatches = 0;
782  }
783  }
784 
785  if (nmatches > 0)
786  if (!store_match(pcc, cur_chr - nmatches, nmatches))
787  goto out_of_memory;
788 
789  /*
790  * We might have allocated more memory than needed, if so free it
791  */
792  if (pcc->cv.nchrs == 0)
793  {
794  free(pcc->cv.chrs);
795  pcc->cv.chrs = NULL;
796  pcc->cv.chrspace = 0;
797  }
798  else if (pcc->cv.nchrs < pcc->cv.chrspace)
799  {
800  newchrs = (chr *) realloc(pcc->cv.chrs,
801  pcc->cv.nchrs * sizeof(chr));
802  if (newchrs == NULL)
803  goto out_of_memory;
804  pcc->cv.chrs = newchrs;
805  pcc->cv.chrspace = pcc->cv.nchrs;
806  }
807  if (pcc->cv.nranges == 0)
808  {
809  free(pcc->cv.ranges);
810  pcc->cv.ranges = NULL;
811  pcc->cv.rangespace = 0;
812  }
813  else if (pcc->cv.nranges < pcc->cv.rangespace)
814  {
815  newchrs = (chr *) realloc(pcc->cv.ranges,
816  pcc->cv.nranges * sizeof(chr) * 2);
817  if (newchrs == NULL)
818  goto out_of_memory;
819  pcc->cv.ranges = newchrs;
820  pcc->cv.rangespace = pcc->cv.nranges;
821  }
822 
823  /*
824  * Success, link it into cache chain
825  */
826  pcc->next = pg_ctype_cache_list;
827  pg_ctype_cache_list = pcc;
828 
829  return &pcc->cv;
830 
831  /*
832  * Failure, clean up
833  */
834 out_of_memory:
835  free(pcc->cv.chrs);
836  free(pcc->cv.ranges);
837  free(pcc);
838 
839  return NULL;
840 }
#define Assert(condition)
Definition: c.h:861
#define OidIsValid(objectId)
Definition: c.h:778
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:1451
@ 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)
static struct cvec * pg_ctype_get_cache(pg_wc_probefunc probefunc, int cclasscode)
#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 Oid pg_regex_collation
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
struct cvec cv
locale_t lt
Definition: pg_locale.h:91
union pg_locale_struct::@156 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