LCOV - code coverage report
Current view: top level - src/backend/regex - regc_pg_locale.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15devel Lines: 145 316 45.9 %
Date: 2021-12-09 04:09:06 Functions: 15 15 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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-2021, 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 "utils/pg_locale.h"
      20             : 
      21             : /*
      22             :  * To provide as much functionality as possible on a variety of platforms,
      23             :  * without going so far as to implement everything from scratch, we use
      24             :  * several implementation strategies depending on the situation:
      25             :  *
      26             :  * 1. In C/POSIX collations, we use hard-wired code.  We can't depend on
      27             :  * the <ctype.h> functions since those will obey LC_CTYPE.  Note that these
      28             :  * collations don't give a fig about multibyte characters.
      29             :  *
      30             :  * 2. In the "default" collation (which is supposed to obey LC_CTYPE):
      31             :  *
      32             :  * 2a. When working in UTF8 encoding, we use the <wctype.h> functions.
      33             :  * This assumes that every platform uses Unicode codepoints directly
      34             :  * as the wchar_t representation of Unicode.  On some platforms
      35             :  * wchar_t is only 16 bits wide, so we have to punt for codepoints > 0xFFFF.
      36             :  *
      37             :  * 2b. In all other encodings, we use the <ctype.h> functions for pg_wchar
      38             :  * values up to 255, and punt for values above that.  This is 100% correct
      39             :  * only in single-byte encodings such as LATINn.  However, non-Unicode
      40             :  * multibyte encodings are mostly Far Eastern character sets for which the
      41             :  * properties being tested here aren't very relevant for higher code values
      42             :  * anyway.  The difficulty with using the <wctype.h> functions with
      43             :  * non-Unicode multibyte encodings is that we can have no certainty that
      44             :  * the platform's wchar_t representation matches what we do in pg_wchar
      45             :  * conversions.
      46             :  *
      47             :  * 3. Other collations are only supported on platforms that HAVE_LOCALE_T.
      48             :  * Here, we use the locale_t-extended forms of the <wctype.h> and <ctype.h>
      49             :  * functions, under exactly the same cases as #2.
      50             :  *
      51             :  * There is one notable difference between cases 2 and 3: in the "default"
      52             :  * collation we force ASCII letters to follow ASCII upcase/downcase rules,
      53             :  * while in a non-default collation we just let the library functions do what
      54             :  * they will.  The case where this matters is treatment of I/i in Turkish,
      55             :  * and the behavior is meant to match the upper()/lower() SQL functions.
      56             :  *
      57             :  * We store the active collation setting in static variables.  In principle
      58             :  * it could be passed down to here via the regex library's "struct vars" data
      59             :  * structure; but that would require somewhat invasive changes in the regex
      60             :  * library, and right now there's no real benefit to be gained from that.
      61             :  *
      62             :  * NB: the coding here assumes pg_wchar is an unsigned type.
      63             :  */
      64             : 
      65             : typedef enum
      66             : {
      67             :     PG_REGEX_LOCALE_C,          /* C locale (encoding independent) */
      68             :     PG_REGEX_LOCALE_WIDE,       /* Use <wctype.h> functions */
      69             :     PG_REGEX_LOCALE_1BYTE,      /* Use <ctype.h> functions */
      70             :     PG_REGEX_LOCALE_WIDE_L,     /* Use locale_t <wctype.h> functions */
      71             :     PG_REGEX_LOCALE_1BYTE_L,    /* Use locale_t <ctype.h> functions */
      72             :     PG_REGEX_LOCALE_ICU         /* Use ICU uchar.h functions */
      73             : } PG_Locale_Strategy;
      74             : 
      75             : static PG_Locale_Strategy pg_regex_strategy;
      76             : static pg_locale_t pg_regex_locale;
      77             : static Oid  pg_regex_collation;
      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,
     158             :      /* A  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     159             :      /* B  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     160             :      /* C  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     161             :      /* D  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     162             :      /* E  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     163             :      /* F  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     164             :      /* G  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     165             :      /* H  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     166             :      /* I  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     167             :      /* J  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     168             :      /* K  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     169             :      /* L  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     170             :      /* M  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     171             :      /* N  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     172             :      /* O  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     173             :      /* P  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     174             :      /* Q  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     175             :      /* R  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     176             :      /* S  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     177             :      /* T  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     178             :      /* U  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     179             :      /* V  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     180             :      /* W  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     181             :      /* X  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     182             :      /* Y  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     183             :      /* Z  */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
     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,
     190             :      /* a  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     191             :      /* b  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     192             :      /* c  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     193             :      /* d  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     194             :      /* e  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     195             :      /* f  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     196             :      /* g  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     197             :      /* h  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     198             :      /* i  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     199             :      /* j  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     200             :      /* k  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     201             :      /* l  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     202             :      /* m  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     203             :      /* n  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     204             :      /* o  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     205             :      /* p  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     206             :      /* q  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     207             :      /* r  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     208             :      /* s  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     209             :      /* t  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     210             :      /* u  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     211             :      /* v  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     212             :      /* w  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     213             :      /* x  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     214             :      /* y  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     215             :      /* z  */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
     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
     232     1522090 : pg_set_regex_collation(Oid collation)
     233             : {
     234     1522090 :     if (lc_ctype_is_c(collation))
     235             :     {
     236             :         /* C/POSIX collations use this path regardless of database encoding */
     237       79470 :         pg_regex_strategy = PG_REGEX_LOCALE_C;
     238       79470 :         pg_regex_locale = 0;
     239       79470 :         pg_regex_collation = C_COLLATION_OID;
     240             :     }
     241             :     else
     242             :     {
     243     1442620 :         if (collation == DEFAULT_COLLATION_OID)
     244     1442620 :             pg_regex_locale = 0;
     245           0 :         else if (OidIsValid(collation))
     246             :         {
     247             :             /*
     248             :              * NB: pg_newlocale_from_collation will fail if not HAVE_LOCALE_T;
     249             :              * the case of pg_regex_locale != 0 but not HAVE_LOCALE_T does not
     250             :              * have to be considered below.
     251             :              */
     252           0 :             pg_regex_locale = pg_newlocale_from_collation(collation);
     253             :         }
     254             :         else
     255             :         {
     256             :             /*
     257             :              * This typically means that the parser could not resolve a
     258             :              * conflict of implicit collations, so report it that way.
     259             :              */
     260           0 :             ereport(ERROR,
     261             :                     (errcode(ERRCODE_INDETERMINATE_COLLATION),
     262             :                      errmsg("could not determine which collation to use for regular expression"),
     263             :                      errhint("Use the COLLATE clause to set the collation explicitly.")));
     264             :         }
     265             : 
     266     1442620 :         if (pg_regex_locale && !pg_regex_locale->deterministic)
     267           0 :             ereport(ERROR,
     268             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     269             :                      errmsg("nondeterministic collations are not supported for regular expressions")));
     270             : 
     271             : #ifdef USE_ICU
     272             :         if (pg_regex_locale && pg_regex_locale->provider == COLLPROVIDER_ICU)
     273             :             pg_regex_strategy = PG_REGEX_LOCALE_ICU;
     274             :         else
     275             : #endif
     276     1442620 :         if (GetDatabaseEncoding() == PG_UTF8)
     277             :         {
     278     1442620 :             if (pg_regex_locale)
     279           0 :                 pg_regex_strategy = PG_REGEX_LOCALE_WIDE_L;
     280             :             else
     281     1442620 :                 pg_regex_strategy = PG_REGEX_LOCALE_WIDE;
     282             :         }
     283             :         else
     284             :         {
     285           0 :             if (pg_regex_locale)
     286           0 :                 pg_regex_strategy = PG_REGEX_LOCALE_1BYTE_L;
     287             :             else
     288           0 :                 pg_regex_strategy = PG_REGEX_LOCALE_1BYTE;
     289             :         }
     290             : 
     291     1442620 :         pg_regex_collation = collation;
     292             :     }
     293     1522090 : }
     294             : 
     295             : static int
     296       71336 : pg_wc_isdigit(pg_wchar c)
     297             : {
     298       71336 :     switch (pg_regex_strategy)
     299             :     {
     300        1374 :         case PG_REGEX_LOCALE_C:
     301        2748 :             return (c <= (pg_wchar) 127 &&
     302        1374 :                     (pg_char_properties[c] & PG_ISDIGIT));
     303       69962 :         case PG_REGEX_LOCALE_WIDE:
     304             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     305       69962 :                 return iswdigit((wint_t) c);
     306             :             /* FALL THRU */
     307             :         case PG_REGEX_LOCALE_1BYTE:
     308           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     309           0 :                     isdigit((unsigned char) c));
     310           0 :         case PG_REGEX_LOCALE_WIDE_L:
     311             : #ifdef HAVE_LOCALE_T
     312             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     313           0 :                 return iswdigit_l((wint_t) c, pg_regex_locale->info.lt);
     314             : #endif
     315             :             /* FALL THRU */
     316             :         case PG_REGEX_LOCALE_1BYTE_L:
     317             : #ifdef HAVE_LOCALE_T
     318           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     319           0 :                     isdigit_l((unsigned char) c, pg_regex_locale->info.lt));
     320             : #endif
     321             :             break;
     322           0 :         case PG_REGEX_LOCALE_ICU:
     323             : #ifdef USE_ICU
     324             :             return u_isdigit(c);
     325             : #endif
     326           0 :             break;
     327             :     }
     328           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     329             : }
     330             : 
     331             : static int
     332        4350 : pg_wc_isalpha(pg_wchar c)
     333             : {
     334        4350 :     switch (pg_regex_strategy)
     335             :     {
     336           0 :         case PG_REGEX_LOCALE_C:
     337           0 :             return (c <= (pg_wchar) 127 &&
     338           0 :                     (pg_char_properties[c] & PG_ISALPHA));
     339        4350 :         case PG_REGEX_LOCALE_WIDE:
     340             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     341        4350 :                 return iswalpha((wint_t) c);
     342             :             /* FALL THRU */
     343             :         case PG_REGEX_LOCALE_1BYTE:
     344           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     345           0 :                     isalpha((unsigned char) c));
     346           0 :         case PG_REGEX_LOCALE_WIDE_L:
     347             : #ifdef HAVE_LOCALE_T
     348             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     349           0 :                 return iswalpha_l((wint_t) c, pg_regex_locale->info.lt);
     350             : #endif
     351             :             /* FALL THRU */
     352             :         case PG_REGEX_LOCALE_1BYTE_L:
     353             : #ifdef HAVE_LOCALE_T
     354           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     355           0 :                     isalpha_l((unsigned char) c, pg_regex_locale->info.lt));
     356             : #endif
     357             :             break;
     358           0 :         case PG_REGEX_LOCALE_ICU:
     359             : #ifdef USE_ICU
     360             :             return u_isalpha(c);
     361             : #endif
     362           0 :             break;
     363             :     }
     364           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     365             : }
     366             : 
     367             : static int
     368       34920 : pg_wc_isalnum(pg_wchar c)
     369             : {
     370       34920 :     switch (pg_regex_strategy)
     371             :     {
     372        1212 :         case PG_REGEX_LOCALE_C:
     373        2424 :             return (c <= (pg_wchar) 127 &&
     374        1212 :                     (pg_char_properties[c] & PG_ISALNUM));
     375       33708 :         case PG_REGEX_LOCALE_WIDE:
     376             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     377       33708 :                 return iswalnum((wint_t) c);
     378             :             /* FALL THRU */
     379             :         case PG_REGEX_LOCALE_1BYTE:
     380           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     381           0 :                     isalnum((unsigned char) c));
     382           0 :         case PG_REGEX_LOCALE_WIDE_L:
     383             : #ifdef HAVE_LOCALE_T
     384             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     385           0 :                 return iswalnum_l((wint_t) c, pg_regex_locale->info.lt);
     386             : #endif
     387             :             /* FALL THRU */
     388             :         case PG_REGEX_LOCALE_1BYTE_L:
     389             : #ifdef HAVE_LOCALE_T
     390           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     391           0 :                     isalnum_l((unsigned char) c, pg_regex_locale->info.lt));
     392             : #endif
     393             :             break;
     394           0 :         case PG_REGEX_LOCALE_ICU:
     395             : #ifdef USE_ICU
     396             :             return u_isalnum(c);
     397             : #endif
     398           0 :             break;
     399             :     }
     400           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     401             : }
     402             : 
     403             : static int
     404       25090 : pg_wc_isword(pg_wchar c)
     405             : {
     406             :     /* We define word characters as alnum class plus underscore */
     407       25090 :     if (c == CHR('_'))
     408          16 :         return 1;
     409       25074 :     return pg_wc_isalnum(c);
     410             : }
     411             : 
     412             : static int
     413        4112 : pg_wc_isupper(pg_wchar c)
     414             : {
     415        4112 :     switch (pg_regex_strategy)
     416             :     {
     417           0 :         case PG_REGEX_LOCALE_C:
     418           0 :             return (c <= (pg_wchar) 127 &&
     419           0 :                     (pg_char_properties[c] & PG_ISUPPER));
     420        4112 :         case PG_REGEX_LOCALE_WIDE:
     421             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     422        4112 :                 return iswupper((wint_t) c);
     423             :             /* FALL THRU */
     424             :         case PG_REGEX_LOCALE_1BYTE:
     425           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     426           0 :                     isupper((unsigned char) c));
     427           0 :         case PG_REGEX_LOCALE_WIDE_L:
     428             : #ifdef HAVE_LOCALE_T
     429             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     430           0 :                 return iswupper_l((wint_t) c, pg_regex_locale->info.lt);
     431             : #endif
     432             :             /* FALL THRU */
     433             :         case PG_REGEX_LOCALE_1BYTE_L:
     434             : #ifdef HAVE_LOCALE_T
     435           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     436           0 :                     isupper_l((unsigned char) c, pg_regex_locale->info.lt));
     437             : #endif
     438             :             break;
     439           0 :         case PG_REGEX_LOCALE_ICU:
     440             : #ifdef USE_ICU
     441             :             return u_isupper(c);
     442             : #endif
     443           0 :             break;
     444             :     }
     445           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     446             : }
     447             : 
     448             : static int
     449        4102 : pg_wc_islower(pg_wchar c)
     450             : {
     451        4102 :     switch (pg_regex_strategy)
     452             :     {
     453           0 :         case PG_REGEX_LOCALE_C:
     454           0 :             return (c <= (pg_wchar) 127 &&
     455           0 :                     (pg_char_properties[c] & PG_ISLOWER));
     456        4102 :         case PG_REGEX_LOCALE_WIDE:
     457             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     458        4102 :                 return iswlower((wint_t) c);
     459             :             /* FALL THRU */
     460             :         case PG_REGEX_LOCALE_1BYTE:
     461           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     462           0 :                     islower((unsigned char) c));
     463           0 :         case PG_REGEX_LOCALE_WIDE_L:
     464             : #ifdef HAVE_LOCALE_T
     465             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     466           0 :                 return iswlower_l((wint_t) c, pg_regex_locale->info.lt);
     467             : #endif
     468             :             /* FALL THRU */
     469             :         case PG_REGEX_LOCALE_1BYTE_L:
     470             : #ifdef HAVE_LOCALE_T
     471           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     472           0 :                     islower_l((unsigned char) c, pg_regex_locale->info.lt));
     473             : #endif
     474             :             break;
     475           0 :         case PG_REGEX_LOCALE_ICU:
     476             : #ifdef USE_ICU
     477             :             return u_islower(c);
     478             : #endif
     479           0 :             break;
     480             :     }
     481           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     482             : }
     483             : 
     484             : static int
     485        4102 : pg_wc_isgraph(pg_wchar c)
     486             : {
     487        4102 :     switch (pg_regex_strategy)
     488             :     {
     489           0 :         case PG_REGEX_LOCALE_C:
     490           0 :             return (c <= (pg_wchar) 127 &&
     491           0 :                     (pg_char_properties[c] & PG_ISGRAPH));
     492        4102 :         case PG_REGEX_LOCALE_WIDE:
     493             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     494        4102 :                 return iswgraph((wint_t) c);
     495             :             /* FALL THRU */
     496             :         case PG_REGEX_LOCALE_1BYTE:
     497           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     498           0 :                     isgraph((unsigned char) c));
     499           0 :         case PG_REGEX_LOCALE_WIDE_L:
     500             : #ifdef HAVE_LOCALE_T
     501             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     502           0 :                 return iswgraph_l((wint_t) c, pg_regex_locale->info.lt);
     503             : #endif
     504             :             /* FALL THRU */
     505             :         case PG_REGEX_LOCALE_1BYTE_L:
     506             : #ifdef HAVE_LOCALE_T
     507           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     508           0 :                     isgraph_l((unsigned char) c, pg_regex_locale->info.lt));
     509             : #endif
     510             :             break;
     511           0 :         case PG_REGEX_LOCALE_ICU:
     512             : #ifdef USE_ICU
     513             :             return u_isgraph(c);
     514             : #endif
     515           0 :             break;
     516             :     }
     517           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     518             : }
     519             : 
     520             : static int
     521        4102 : pg_wc_isprint(pg_wchar c)
     522             : {
     523        4102 :     switch (pg_regex_strategy)
     524             :     {
     525           0 :         case PG_REGEX_LOCALE_C:
     526           0 :             return (c <= (pg_wchar) 127 &&
     527           0 :                     (pg_char_properties[c] & PG_ISPRINT));
     528        4102 :         case PG_REGEX_LOCALE_WIDE:
     529             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     530        4102 :                 return iswprint((wint_t) c);
     531             :             /* FALL THRU */
     532             :         case PG_REGEX_LOCALE_1BYTE:
     533           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     534           0 :                     isprint((unsigned char) c));
     535           0 :         case PG_REGEX_LOCALE_WIDE_L:
     536             : #ifdef HAVE_LOCALE_T
     537             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     538           0 :                 return iswprint_l((wint_t) c, pg_regex_locale->info.lt);
     539             : #endif
     540             :             /* FALL THRU */
     541             :         case PG_REGEX_LOCALE_1BYTE_L:
     542             : #ifdef HAVE_LOCALE_T
     543           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     544           0 :                     isprint_l((unsigned char) c, pg_regex_locale->info.lt));
     545             : #endif
     546             :             break;
     547           0 :         case PG_REGEX_LOCALE_ICU:
     548             : #ifdef USE_ICU
     549             :             return u_isprint(c);
     550             : #endif
     551           0 :             break;
     552             :     }
     553           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     554             : }
     555             : 
     556             : static int
     557        4102 : pg_wc_ispunct(pg_wchar c)
     558             : {
     559        4102 :     switch (pg_regex_strategy)
     560             :     {
     561           0 :         case PG_REGEX_LOCALE_C:
     562           0 :             return (c <= (pg_wchar) 127 &&
     563           0 :                     (pg_char_properties[c] & PG_ISPUNCT));
     564        4102 :         case PG_REGEX_LOCALE_WIDE:
     565             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     566        4102 :                 return iswpunct((wint_t) c);
     567             :             /* FALL THRU */
     568             :         case PG_REGEX_LOCALE_1BYTE:
     569           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     570           0 :                     ispunct((unsigned char) c));
     571           0 :         case PG_REGEX_LOCALE_WIDE_L:
     572             : #ifdef HAVE_LOCALE_T
     573             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     574           0 :                 return iswpunct_l((wint_t) c, pg_regex_locale->info.lt);
     575             : #endif
     576             :             /* FALL THRU */
     577             :         case PG_REGEX_LOCALE_1BYTE_L:
     578             : #ifdef HAVE_LOCALE_T
     579           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     580           0 :                     ispunct_l((unsigned char) c, pg_regex_locale->info.lt));
     581             : #endif
     582             :             break;
     583           0 :         case PG_REGEX_LOCALE_ICU:
     584             : #ifdef USE_ICU
     585             :             return u_ispunct(c);
     586             : #endif
     587           0 :             break;
     588             :     }
     589           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     590             : }
     591             : 
     592             : static int
     593       39508 : pg_wc_isspace(pg_wchar c)
     594             : {
     595       39508 :     switch (pg_regex_strategy)
     596             :     {
     597           0 :         case PG_REGEX_LOCALE_C:
     598           0 :             return (c <= (pg_wchar) 127 &&
     599           0 :                     (pg_char_properties[c] & PG_ISSPACE));
     600       39508 :         case PG_REGEX_LOCALE_WIDE:
     601             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     602       39508 :                 return iswspace((wint_t) c);
     603             :             /* FALL THRU */
     604             :         case PG_REGEX_LOCALE_1BYTE:
     605           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     606           0 :                     isspace((unsigned char) c));
     607           0 :         case PG_REGEX_LOCALE_WIDE_L:
     608             : #ifdef HAVE_LOCALE_T
     609             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     610           0 :                 return iswspace_l((wint_t) c, pg_regex_locale->info.lt);
     611             : #endif
     612             :             /* FALL THRU */
     613             :         case PG_REGEX_LOCALE_1BYTE_L:
     614             : #ifdef HAVE_LOCALE_T
     615           0 :             return (c <= (pg_wchar) UCHAR_MAX &&
     616           0 :                     isspace_l((unsigned char) c, pg_regex_locale->info.lt));
     617             : #endif
     618             :             break;
     619           0 :         case PG_REGEX_LOCALE_ICU:
     620             : #ifdef USE_ICU
     621             :             return u_isspace(c);
     622             : #endif
     623           0 :             break;
     624             :     }
     625           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     626             : }
     627             : 
     628             : static pg_wchar
     629        9920 : pg_wc_toupper(pg_wchar c)
     630             : {
     631        9920 :     switch (pg_regex_strategy)
     632             :     {
     633        1026 :         case PG_REGEX_LOCALE_C:
     634        1026 :             if (c <= (pg_wchar) 127)
     635        1026 :                 return pg_ascii_toupper((unsigned char) c);
     636           0 :             return c;
     637        8894 :         case PG_REGEX_LOCALE_WIDE:
     638             :             /* force C behavior for ASCII characters, per comments above */
     639        8894 :             if (c <= (pg_wchar) 127)
     640         698 :                 return pg_ascii_toupper((unsigned char) c);
     641             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     642        8196 :                 return towupper((wint_t) c);
     643             :             /* FALL THRU */
     644             :         case PG_REGEX_LOCALE_1BYTE:
     645             :             /* force C behavior for ASCII characters, per comments above */
     646           0 :             if (c <= (pg_wchar) 127)
     647           0 :                 return pg_ascii_toupper((unsigned char) c);
     648           0 :             if (c <= (pg_wchar) UCHAR_MAX)
     649           0 :                 return toupper((unsigned char) c);
     650           0 :             return c;
     651           0 :         case PG_REGEX_LOCALE_WIDE_L:
     652             : #ifdef HAVE_LOCALE_T
     653             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     654           0 :                 return towupper_l((wint_t) c, pg_regex_locale->info.lt);
     655             : #endif
     656             :             /* FALL THRU */
     657             :         case PG_REGEX_LOCALE_1BYTE_L:
     658             : #ifdef HAVE_LOCALE_T
     659           0 :             if (c <= (pg_wchar) UCHAR_MAX)
     660           0 :                 return toupper_l((unsigned char) c, pg_regex_locale->info.lt);
     661             : #endif
     662           0 :             return c;
     663           0 :         case PG_REGEX_LOCALE_ICU:
     664             : #ifdef USE_ICU
     665             :             return u_toupper(c);
     666             : #endif
     667           0 :             break;
     668             :     }
     669           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     670             : }
     671             : 
     672             : static pg_wchar
     673        9924 : pg_wc_tolower(pg_wchar c)
     674             : {
     675        9924 :     switch (pg_regex_strategy)
     676             :     {
     677        1026 :         case PG_REGEX_LOCALE_C:
     678        1026 :             if (c <= (pg_wchar) 127)
     679        1026 :                 return pg_ascii_tolower((unsigned char) c);
     680           0 :             return c;
     681        8898 :         case PG_REGEX_LOCALE_WIDE:
     682             :             /* force C behavior for ASCII characters, per comments above */
     683        8898 :             if (c <= (pg_wchar) 127)
     684         702 :                 return pg_ascii_tolower((unsigned char) c);
     685             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     686        8196 :                 return towlower((wint_t) c);
     687             :             /* FALL THRU */
     688             :         case PG_REGEX_LOCALE_1BYTE:
     689             :             /* force C behavior for ASCII characters, per comments above */
     690           0 :             if (c <= (pg_wchar) 127)
     691           0 :                 return pg_ascii_tolower((unsigned char) c);
     692           0 :             if (c <= (pg_wchar) UCHAR_MAX)
     693           0 :                 return tolower((unsigned char) c);
     694           0 :             return c;
     695           0 :         case PG_REGEX_LOCALE_WIDE_L:
     696             : #ifdef HAVE_LOCALE_T
     697             :             if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
     698           0 :                 return towlower_l((wint_t) c, pg_regex_locale->info.lt);
     699             : #endif
     700             :             /* FALL THRU */
     701             :         case PG_REGEX_LOCALE_1BYTE_L:
     702             : #ifdef HAVE_LOCALE_T
     703           0 :             if (c <= (pg_wchar) UCHAR_MAX)
     704           0 :                 return tolower_l((unsigned char) c, pg_regex_locale->info.lt);
     705             : #endif
     706           0 :             return c;
     707           0 :         case PG_REGEX_LOCALE_ICU:
     708             : #ifdef USE_ICU
     709             :             return u_tolower(c);
     710             : #endif
     711           0 :             break;
     712             :     }
     713           0 :     return 0;                   /* can't get here, but keep compiler quiet */
     714             : }
     715             : 
     716             : 
     717             : /*
     718             :  * These functions cache the results of probing libc's ctype behavior for
     719             :  * all character codes of interest in a given encoding/collation.  The
     720             :  * result is provided as a "struct cvec", but notice that the representation
     721             :  * is a touch different from a cvec created by regc_cvec.c: we allocate the
     722             :  * chrs[] and ranges[] arrays separately from the struct so that we can
     723             :  * realloc them larger at need.  This is okay since the cvecs made here
     724             :  * should never be freed by freecvec().
     725             :  *
     726             :  * We use malloc not palloc since we mustn't lose control on out-of-memory;
     727             :  * the main regex code expects us to return a failure indication instead.
     728             :  */
     729             : 
     730             : typedef int (*pg_wc_probefunc) (pg_wchar c);
     731             : 
     732             : typedef struct pg_ctype_cache
     733             : {
     734             :     pg_wc_probefunc probefunc;  /* pg_wc_isalpha or a sibling */
     735             :     Oid         collation;      /* collation this entry is for */
     736             :     struct cvec cv;             /* cache entry contents */
     737             :     struct pg_ctype_cache *next;    /* chain link */
     738             : } pg_ctype_cache;
     739             : 
     740             : static pg_ctype_cache *pg_ctype_cache_list = NULL;
     741             : 
     742             : /*
     743             :  * Add a chr or range to pcc->cv; return false if run out of memory
     744             :  */
     745             : static bool
     746        2232 : store_match(pg_ctype_cache *pcc, pg_wchar chr1, int nchrs)
     747             : {
     748             :     chr        *newchrs;
     749             : 
     750        2232 :     if (nchrs > 1)
     751             :     {
     752         950 :         if (pcc->cv.nranges >= pcc->cv.rangespace)
     753             :         {
     754           0 :             pcc->cv.rangespace *= 2;
     755           0 :             newchrs = (chr *) realloc(pcc->cv.ranges,
     756           0 :                                       pcc->cv.rangespace * sizeof(chr) * 2);
     757           0 :             if (newchrs == NULL)
     758           0 :                 return false;
     759           0 :             pcc->cv.ranges = newchrs;
     760             :         }
     761         950 :         pcc->cv.ranges[pcc->cv.nranges * 2] = chr1;
     762         950 :         pcc->cv.ranges[pcc->cv.nranges * 2 + 1] = chr1 + nchrs - 1;
     763         950 :         pcc->cv.nranges++;
     764             :     }
     765             :     else
     766             :     {
     767             :         assert(nchrs == 1);
     768        1282 :         if (pcc->cv.nchrs >= pcc->cv.chrspace)
     769             :         {
     770           4 :             pcc->cv.chrspace *= 2;
     771           4 :             newchrs = (chr *) realloc(pcc->cv.chrs,
     772           4 :                                       pcc->cv.chrspace * sizeof(chr));
     773           4 :             if (newchrs == NULL)
     774           0 :                 return false;
     775           4 :             pcc->cv.chrs = newchrs;
     776             :         }
     777        1282 :         pcc->cv.chrs[pcc->cv.nchrs++] = chr1;
     778             :     }
     779        2232 :     return true;
     780             : }
     781             : 
     782             : /*
     783             :  * Given a probe function (e.g., pg_wc_isalpha) get a struct cvec for all
     784             :  * chrs satisfying the probe function.  The active collation is the one
     785             :  * previously set by pg_set_regex_collation.  Return NULL if out of memory.
     786             :  *
     787             :  * Note that the result must not be freed or modified by caller.
     788             :  */
     789             : static struct cvec *
     790         518 : pg_ctype_get_cache(pg_wc_probefunc probefunc, int cclasscode)
     791             : {
     792             :     pg_ctype_cache *pcc;
     793             :     pg_wchar    max_chr;
     794             :     pg_wchar    cur_chr;
     795             :     int         nmatches;
     796             :     chr        *newchrs;
     797             : 
     798             :     /*
     799             :      * Do we already have the answer cached?
     800             :      */
     801        1174 :     for (pcc = pg_ctype_cache_list; pcc != NULL; pcc = pcc->next)
     802             :     {
     803        1080 :         if (pcc->probefunc == probefunc &&
     804         456 :             pcc->collation == pg_regex_collation)
     805         424 :             return &pcc->cv;
     806             :     }
     807             : 
     808             :     /*
     809             :      * Nope, so initialize some workspace ...
     810             :      */
     811          94 :     pcc = (pg_ctype_cache *) malloc(sizeof(pg_ctype_cache));
     812          94 :     if (pcc == NULL)
     813           0 :         return NULL;
     814          94 :     pcc->probefunc = probefunc;
     815          94 :     pcc->collation = pg_regex_collation;
     816          94 :     pcc->cv.nchrs = 0;
     817          94 :     pcc->cv.chrspace = 128;
     818          94 :     pcc->cv.chrs = (chr *) malloc(pcc->cv.chrspace * sizeof(chr));
     819          94 :     pcc->cv.nranges = 0;
     820          94 :     pcc->cv.rangespace = 64;
     821          94 :     pcc->cv.ranges = (chr *) malloc(pcc->cv.rangespace * sizeof(chr) * 2);
     822          94 :     if (pcc->cv.chrs == NULL || pcc->cv.ranges == NULL)
     823           0 :         goto out_of_memory;
     824          94 :     pcc->cv.cclasscode = cclasscode;
     825             : 
     826             :     /*
     827             :      * Decide how many character codes we ought to look through.  In general
     828             :      * we don't go past MAX_SIMPLE_CHR; chr codes above that are handled at
     829             :      * runtime using the "high colormap" mechanism.  However, in C locale
     830             :      * there's no need to go further than 127, and if we only have a 1-byte
     831             :      * <ctype.h> API there's no need to go further than that can handle.
     832             :      *
     833             :      * If it's not MAX_SIMPLE_CHR that's constraining the search, mark the
     834             :      * output cvec as not having any locale-dependent behavior, since there
     835             :      * will be no need to do any run-time locale checks.  (The #if's here
     836             :      * would always be true for production values of MAX_SIMPLE_CHR, but it's
     837             :      * useful to allow it to be small for testing purposes.)
     838             :      */
     839          94 :     switch (pg_regex_strategy)
     840             :     {
     841          14 :         case PG_REGEX_LOCALE_C:
     842             : #if MAX_SIMPLE_CHR >= 127
     843          14 :             max_chr = (pg_wchar) 127;
     844          14 :             pcc->cv.cclasscode = -1;
     845             : #else
     846             :             max_chr = (pg_wchar) MAX_SIMPLE_CHR;
     847             : #endif
     848          14 :             break;
     849          80 :         case PG_REGEX_LOCALE_WIDE:
     850             :         case PG_REGEX_LOCALE_WIDE_L:
     851          80 :             max_chr = (pg_wchar) MAX_SIMPLE_CHR;
     852          80 :             break;
     853           0 :         case PG_REGEX_LOCALE_1BYTE:
     854             :         case PG_REGEX_LOCALE_1BYTE_L:
     855             : #if MAX_SIMPLE_CHR >= UCHAR_MAX
     856           0 :             max_chr = (pg_wchar) UCHAR_MAX;
     857           0 :             pcc->cv.cclasscode = -1;
     858             : #else
     859             :             max_chr = (pg_wchar) MAX_SIMPLE_CHR;
     860             : #endif
     861           0 :             break;
     862           0 :         case PG_REGEX_LOCALE_ICU:
     863           0 :             max_chr = (pg_wchar) MAX_SIMPLE_CHR;
     864           0 :             break;
     865           0 :         default:
     866           0 :             max_chr = 0;        /* can't get here, but keep compiler quiet */
     867           0 :             break;
     868             :     }
     869             : 
     870             :     /*
     871             :      * And scan 'em ...
     872             :      */
     873          94 :     nmatches = 0;               /* number of consecutive matches */
     874             : 
     875      165726 :     for (cur_chr = 0; cur_chr <= max_chr; cur_chr++)
     876             :     {
     877      165632 :         if ((*probefunc) (cur_chr))
     878       39544 :             nmatches++;
     879      126088 :         else if (nmatches > 0)
     880             :         {
     881        2226 :             if (!store_match(pcc, cur_chr - nmatches, nmatches))
     882           0 :                 goto out_of_memory;
     883        2226 :             nmatches = 0;
     884             :         }
     885             :     }
     886             : 
     887          94 :     if (nmatches > 0)
     888           6 :         if (!store_match(pcc, cur_chr - nmatches, nmatches))
     889           0 :             goto out_of_memory;
     890             : 
     891             :     /*
     892             :      * We might have allocated more memory than needed, if so free it
     893             :      */
     894          94 :     if (pcc->cv.nchrs == 0)
     895             :     {
     896          44 :         free(pcc->cv.chrs);
     897          44 :         pcc->cv.chrs = NULL;
     898          44 :         pcc->cv.chrspace = 0;
     899             :     }
     900          50 :     else if (pcc->cv.nchrs < pcc->cv.chrspace)
     901             :     {
     902          50 :         newchrs = (chr *) realloc(pcc->cv.chrs,
     903          50 :                                   pcc->cv.nchrs * sizeof(chr));
     904          50 :         if (newchrs == NULL)
     905           0 :             goto out_of_memory;
     906          50 :         pcc->cv.chrs = newchrs;
     907          50 :         pcc->cv.chrspace = pcc->cv.nchrs;
     908             :     }
     909          94 :     if (pcc->cv.nranges == 0)
     910             :     {
     911           0 :         free(pcc->cv.ranges);
     912           0 :         pcc->cv.ranges = NULL;
     913           0 :         pcc->cv.rangespace = 0;
     914             :     }
     915          94 :     else if (pcc->cv.nranges < pcc->cv.rangespace)
     916             :     {
     917          94 :         newchrs = (chr *) realloc(pcc->cv.ranges,
     918          94 :                                   pcc->cv.nranges * sizeof(chr) * 2);
     919          94 :         if (newchrs == NULL)
     920           0 :             goto out_of_memory;
     921          94 :         pcc->cv.ranges = newchrs;
     922          94 :         pcc->cv.rangespace = pcc->cv.nranges;
     923             :     }
     924             : 
     925             :     /*
     926             :      * Success, link it into cache chain
     927             :      */
     928          94 :     pcc->next = pg_ctype_cache_list;
     929          94 :     pg_ctype_cache_list = pcc;
     930             : 
     931          94 :     return &pcc->cv;
     932             : 
     933             :     /*
     934             :      * Failure, clean up
     935             :      */
     936           0 : out_of_memory:
     937           0 :     if (pcc->cv.chrs)
     938           0 :         free(pcc->cv.chrs);
     939           0 :     if (pcc->cv.ranges)
     940           0 :         free(pcc->cv.ranges);
     941           0 :     free(pcc);
     942             : 
     943           0 :     return NULL;
     944             : }

Generated by: LCOV version 1.14