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
pg_set_regex_collation(Oid collation)232 pg_set_regex_collation(Oid collation)
233 {
234 if (lc_ctype_is_c(collation))
235 {
236 /* C/POSIX collations use this path regardless of database encoding */
237 pg_regex_strategy = PG_REGEX_LOCALE_C;
238 pg_regex_locale = 0;
239 pg_regex_collation = C_COLLATION_OID;
240 }
241 else
242 {
243 if (collation == DEFAULT_COLLATION_OID)
244 pg_regex_locale = 0;
245 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 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 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 if (pg_regex_locale && !pg_regex_locale->deterministic)
267 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 if (GetDatabaseEncoding() == PG_UTF8)
277 {
278 if (pg_regex_locale)
279 pg_regex_strategy = PG_REGEX_LOCALE_WIDE_L;
280 else
281 pg_regex_strategy = PG_REGEX_LOCALE_WIDE;
282 }
283 else
284 {
285 if (pg_regex_locale)
286 pg_regex_strategy = PG_REGEX_LOCALE_1BYTE_L;
287 else
288 pg_regex_strategy = PG_REGEX_LOCALE_1BYTE;
289 }
290
291 pg_regex_collation = collation;
292 }
293 }
294
295 static int
pg_wc_isdigit(pg_wchar c)296 pg_wc_isdigit(pg_wchar c)
297 {
298 switch (pg_regex_strategy)
299 {
300 case PG_REGEX_LOCALE_C:
301 return (c <= (pg_wchar) 127 &&
302 (pg_char_properties[c] & PG_ISDIGIT));
303 case PG_REGEX_LOCALE_WIDE:
304 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
305 return iswdigit((wint_t) c);
306 /* FALL THRU */
307 case PG_REGEX_LOCALE_1BYTE:
308 return (c <= (pg_wchar) UCHAR_MAX &&
309 isdigit((unsigned char) c));
310 case PG_REGEX_LOCALE_WIDE_L:
311 #ifdef HAVE_LOCALE_T
312 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
313 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 return (c <= (pg_wchar) UCHAR_MAX &&
319 isdigit_l((unsigned char) c, pg_regex_locale->info.lt));
320 #endif
321 break;
322 case PG_REGEX_LOCALE_ICU:
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
pg_wc_isalpha(pg_wchar c)332 pg_wc_isalpha(pg_wchar c)
333 {
334 switch (pg_regex_strategy)
335 {
336 case PG_REGEX_LOCALE_C:
337 return (c <= (pg_wchar) 127 &&
338 (pg_char_properties[c] & PG_ISALPHA));
339 case PG_REGEX_LOCALE_WIDE:
340 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
341 return iswalpha((wint_t) c);
342 /* FALL THRU */
343 case PG_REGEX_LOCALE_1BYTE:
344 return (c <= (pg_wchar) UCHAR_MAX &&
345 isalpha((unsigned char) c));
346 case PG_REGEX_LOCALE_WIDE_L:
347 #ifdef HAVE_LOCALE_T
348 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
349 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 return (c <= (pg_wchar) UCHAR_MAX &&
355 isalpha_l((unsigned char) c, pg_regex_locale->info.lt));
356 #endif
357 break;
358 case PG_REGEX_LOCALE_ICU:
359 #ifdef USE_ICU
360 return u_isalpha(c);
361 #endif
362 break;
363 }
364 return 0; /* can't get here, but keep compiler quiet */
365 }
366
367 static int
pg_wc_isalnum(pg_wchar c)368 pg_wc_isalnum(pg_wchar c)
369 {
370 switch (pg_regex_strategy)
371 {
372 case PG_REGEX_LOCALE_C:
373 return (c <= (pg_wchar) 127 &&
374 (pg_char_properties[c] & PG_ISALNUM));
375 case PG_REGEX_LOCALE_WIDE:
376 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
377 return iswalnum((wint_t) c);
378 /* FALL THRU */
379 case PG_REGEX_LOCALE_1BYTE:
380 return (c <= (pg_wchar) UCHAR_MAX &&
381 isalnum((unsigned char) c));
382 case PG_REGEX_LOCALE_WIDE_L:
383 #ifdef HAVE_LOCALE_T
384 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
385 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 return (c <= (pg_wchar) UCHAR_MAX &&
391 isalnum_l((unsigned char) c, pg_regex_locale->info.lt));
392 #endif
393 break;
394 case PG_REGEX_LOCALE_ICU:
395 #ifdef USE_ICU
396 return u_isalnum(c);
397 #endif
398 break;
399 }
400 return 0; /* can't get here, but keep compiler quiet */
401 }
402
403 static int
pg_wc_isword(pg_wchar c)404 pg_wc_isword(pg_wchar c)
405 {
406 /* We define word characters as alnum class plus underscore */
407 if (c == CHR('_'))
408 return 1;
409 return pg_wc_isalnum(c);
410 }
411
412 static int
pg_wc_isupper(pg_wchar c)413 pg_wc_isupper(pg_wchar c)
414 {
415 switch (pg_regex_strategy)
416 {
417 case PG_REGEX_LOCALE_C:
418 return (c <= (pg_wchar) 127 &&
419 (pg_char_properties[c] & PG_ISUPPER));
420 case PG_REGEX_LOCALE_WIDE:
421 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
422 return iswupper((wint_t) c);
423 /* FALL THRU */
424 case PG_REGEX_LOCALE_1BYTE:
425 return (c <= (pg_wchar) UCHAR_MAX &&
426 isupper((unsigned char) c));
427 case PG_REGEX_LOCALE_WIDE_L:
428 #ifdef HAVE_LOCALE_T
429 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
430 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 return (c <= (pg_wchar) UCHAR_MAX &&
436 isupper_l((unsigned char) c, pg_regex_locale->info.lt));
437 #endif
438 break;
439 case PG_REGEX_LOCALE_ICU:
440 #ifdef USE_ICU
441 return u_isupper(c);
442 #endif
443 break;
444 }
445 return 0; /* can't get here, but keep compiler quiet */
446 }
447
448 static int
pg_wc_islower(pg_wchar c)449 pg_wc_islower(pg_wchar c)
450 {
451 switch (pg_regex_strategy)
452 {
453 case PG_REGEX_LOCALE_C:
454 return (c <= (pg_wchar) 127 &&
455 (pg_char_properties[c] & PG_ISLOWER));
456 case PG_REGEX_LOCALE_WIDE:
457 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
458 return iswlower((wint_t) c);
459 /* FALL THRU */
460 case PG_REGEX_LOCALE_1BYTE:
461 return (c <= (pg_wchar) UCHAR_MAX &&
462 islower((unsigned char) c));
463 case PG_REGEX_LOCALE_WIDE_L:
464 #ifdef HAVE_LOCALE_T
465 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
466 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 return (c <= (pg_wchar) UCHAR_MAX &&
472 islower_l((unsigned char) c, pg_regex_locale->info.lt));
473 #endif
474 break;
475 case PG_REGEX_LOCALE_ICU:
476 #ifdef USE_ICU
477 return u_islower(c);
478 #endif
479 break;
480 }
481 return 0; /* can't get here, but keep compiler quiet */
482 }
483
484 static int
pg_wc_isgraph(pg_wchar c)485 pg_wc_isgraph(pg_wchar c)
486 {
487 switch (pg_regex_strategy)
488 {
489 case PG_REGEX_LOCALE_C:
490 return (c <= (pg_wchar) 127 &&
491 (pg_char_properties[c] & PG_ISGRAPH));
492 case PG_REGEX_LOCALE_WIDE:
493 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
494 return iswgraph((wint_t) c);
495 /* FALL THRU */
496 case PG_REGEX_LOCALE_1BYTE:
497 return (c <= (pg_wchar) UCHAR_MAX &&
498 isgraph((unsigned char) c));
499 case PG_REGEX_LOCALE_WIDE_L:
500 #ifdef HAVE_LOCALE_T
501 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
502 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 return (c <= (pg_wchar) UCHAR_MAX &&
508 isgraph_l((unsigned char) c, pg_regex_locale->info.lt));
509 #endif
510 break;
511 case PG_REGEX_LOCALE_ICU:
512 #ifdef USE_ICU
513 return u_isgraph(c);
514 #endif
515 break;
516 }
517 return 0; /* can't get here, but keep compiler quiet */
518 }
519
520 static int
pg_wc_isprint(pg_wchar c)521 pg_wc_isprint(pg_wchar c)
522 {
523 switch (pg_regex_strategy)
524 {
525 case PG_REGEX_LOCALE_C:
526 return (c <= (pg_wchar) 127 &&
527 (pg_char_properties[c] & PG_ISPRINT));
528 case PG_REGEX_LOCALE_WIDE:
529 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
530 return iswprint((wint_t) c);
531 /* FALL THRU */
532 case PG_REGEX_LOCALE_1BYTE:
533 return (c <= (pg_wchar) UCHAR_MAX &&
534 isprint((unsigned char) c));
535 case PG_REGEX_LOCALE_WIDE_L:
536 #ifdef HAVE_LOCALE_T
537 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
538 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 return (c <= (pg_wchar) UCHAR_MAX &&
544 isprint_l((unsigned char) c, pg_regex_locale->info.lt));
545 #endif
546 break;
547 case PG_REGEX_LOCALE_ICU:
548 #ifdef USE_ICU
549 return u_isprint(c);
550 #endif
551 break;
552 }
553 return 0; /* can't get here, but keep compiler quiet */
554 }
555
556 static int
pg_wc_ispunct(pg_wchar c)557 pg_wc_ispunct(pg_wchar c)
558 {
559 switch (pg_regex_strategy)
560 {
561 case PG_REGEX_LOCALE_C:
562 return (c <= (pg_wchar) 127 &&
563 (pg_char_properties[c] & PG_ISPUNCT));
564 case PG_REGEX_LOCALE_WIDE:
565 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
566 return iswpunct((wint_t) c);
567 /* FALL THRU */
568 case PG_REGEX_LOCALE_1BYTE:
569 return (c <= (pg_wchar) UCHAR_MAX &&
570 ispunct((unsigned char) c));
571 case PG_REGEX_LOCALE_WIDE_L:
572 #ifdef HAVE_LOCALE_T
573 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
574 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 return (c <= (pg_wchar) UCHAR_MAX &&
580 ispunct_l((unsigned char) c, pg_regex_locale->info.lt));
581 #endif
582 break;
583 case PG_REGEX_LOCALE_ICU:
584 #ifdef USE_ICU
585 return u_ispunct(c);
586 #endif
587 break;
588 }
589 return 0; /* can't get here, but keep compiler quiet */
590 }
591
592 static int
pg_wc_isspace(pg_wchar c)593 pg_wc_isspace(pg_wchar c)
594 {
595 switch (pg_regex_strategy)
596 {
597 case PG_REGEX_LOCALE_C:
598 return (c <= (pg_wchar) 127 &&
599 (pg_char_properties[c] & PG_ISSPACE));
600 case PG_REGEX_LOCALE_WIDE:
601 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
602 return iswspace((wint_t) c);
603 /* FALL THRU */
604 case PG_REGEX_LOCALE_1BYTE:
605 return (c <= (pg_wchar) UCHAR_MAX &&
606 isspace((unsigned char) c));
607 case PG_REGEX_LOCALE_WIDE_L:
608 #ifdef HAVE_LOCALE_T
609 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
610 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 return (c <= (pg_wchar) UCHAR_MAX &&
616 isspace_l((unsigned char) c, pg_regex_locale->info.lt));
617 #endif
618 break;
619 case PG_REGEX_LOCALE_ICU:
620 #ifdef USE_ICU
621 return u_isspace(c);
622 #endif
623 break;
624 }
625 return 0; /* can't get here, but keep compiler quiet */
626 }
627
628 static pg_wchar
pg_wc_toupper(pg_wchar c)629 pg_wc_toupper(pg_wchar c)
630 {
631 switch (pg_regex_strategy)
632 {
633 case PG_REGEX_LOCALE_C:
634 if (c <= (pg_wchar) 127)
635 return pg_ascii_toupper((unsigned char) c);
636 return c;
637 case PG_REGEX_LOCALE_WIDE:
638 /* force C behavior for ASCII characters, per comments above */
639 if (c <= (pg_wchar) 127)
640 return pg_ascii_toupper((unsigned char) c);
641 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
642 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 if (c <= (pg_wchar) 127)
647 return pg_ascii_toupper((unsigned char) c);
648 if (c <= (pg_wchar) UCHAR_MAX)
649 return toupper((unsigned char) c);
650 return c;
651 case PG_REGEX_LOCALE_WIDE_L:
652 #ifdef HAVE_LOCALE_T
653 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
654 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 if (c <= (pg_wchar) UCHAR_MAX)
660 return toupper_l((unsigned char) c, pg_regex_locale->info.lt);
661 #endif
662 return c;
663 case PG_REGEX_LOCALE_ICU:
664 #ifdef USE_ICU
665 return u_toupper(c);
666 #endif
667 break;
668 }
669 return 0; /* can't get here, but keep compiler quiet */
670 }
671
672 static pg_wchar
pg_wc_tolower(pg_wchar c)673 pg_wc_tolower(pg_wchar c)
674 {
675 switch (pg_regex_strategy)
676 {
677 case PG_REGEX_LOCALE_C:
678 if (c <= (pg_wchar) 127)
679 return pg_ascii_tolower((unsigned char) c);
680 return c;
681 case PG_REGEX_LOCALE_WIDE:
682 /* force C behavior for ASCII characters, per comments above */
683 if (c <= (pg_wchar) 127)
684 return pg_ascii_tolower((unsigned char) c);
685 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
686 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 if (c <= (pg_wchar) 127)
691 return pg_ascii_tolower((unsigned char) c);
692 if (c <= (pg_wchar) UCHAR_MAX)
693 return tolower((unsigned char) c);
694 return c;
695 case PG_REGEX_LOCALE_WIDE_L:
696 #ifdef HAVE_LOCALE_T
697 if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
698 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 if (c <= (pg_wchar) UCHAR_MAX)
704 return tolower_l((unsigned char) c, pg_regex_locale->info.lt);
705 #endif
706 return c;
707 case PG_REGEX_LOCALE_ICU:
708 #ifdef USE_ICU
709 return u_tolower(c);
710 #endif
711 break;
712 }
713 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
store_match(pg_ctype_cache * pcc,pg_wchar chr1,int nchrs)746 store_match(pg_ctype_cache *pcc, pg_wchar chr1, int nchrs)
747 {
748 chr *newchrs;
749
750 if (nchrs > 1)
751 {
752 if (pcc->cv.nranges >= pcc->cv.rangespace)
753 {
754 pcc->cv.rangespace *= 2;
755 newchrs = (chr *) realloc(pcc->cv.ranges,
756 pcc->cv.rangespace * sizeof(chr) * 2);
757 if (newchrs == NULL)
758 return false;
759 pcc->cv.ranges = newchrs;
760 }
761 pcc->cv.ranges[pcc->cv.nranges * 2] = chr1;
762 pcc->cv.ranges[pcc->cv.nranges * 2 + 1] = chr1 + nchrs - 1;
763 pcc->cv.nranges++;
764 }
765 else
766 {
767 assert(nchrs == 1);
768 if (pcc->cv.nchrs >= pcc->cv.chrspace)
769 {
770 pcc->cv.chrspace *= 2;
771 newchrs = (chr *) realloc(pcc->cv.chrs,
772 pcc->cv.chrspace * sizeof(chr));
773 if (newchrs == NULL)
774 return false;
775 pcc->cv.chrs = newchrs;
776 }
777 pcc->cv.chrs[pcc->cv.nchrs++] = chr1;
778 }
779 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 *
pg_ctype_get_cache(pg_wc_probefunc probefunc,int cclasscode)790 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 for (pcc = pg_ctype_cache_list; pcc != NULL; pcc = pcc->next)
802 {
803 if (pcc->probefunc == probefunc &&
804 pcc->collation == pg_regex_collation)
805 return &pcc->cv;
806 }
807
808 /*
809 * Nope, so initialize some workspace ...
810 */
811 pcc = (pg_ctype_cache *) malloc(sizeof(pg_ctype_cache));
812 if (pcc == NULL)
813 return NULL;
814 pcc->probefunc = probefunc;
815 pcc->collation = pg_regex_collation;
816 pcc->cv.nchrs = 0;
817 pcc->cv.chrspace = 128;
818 pcc->cv.chrs = (chr *) malloc(pcc->cv.chrspace * sizeof(chr));
819 pcc->cv.nranges = 0;
820 pcc->cv.rangespace = 64;
821 pcc->cv.ranges = (chr *) malloc(pcc->cv.rangespace * sizeof(chr) * 2);
822 if (pcc->cv.chrs == NULL || pcc->cv.ranges == NULL)
823 goto out_of_memory;
824 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 switch (pg_regex_strategy)
840 {
841 case PG_REGEX_LOCALE_C:
842 #if MAX_SIMPLE_CHR >= 127
843 max_chr = (pg_wchar) 127;
844 pcc->cv.cclasscode = -1;
845 #else
846 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
847 #endif
848 break;
849 case PG_REGEX_LOCALE_WIDE:
850 case PG_REGEX_LOCALE_WIDE_L:
851 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
852 break;
853 case PG_REGEX_LOCALE_1BYTE:
854 case PG_REGEX_LOCALE_1BYTE_L:
855 #if MAX_SIMPLE_CHR >= UCHAR_MAX
856 max_chr = (pg_wchar) UCHAR_MAX;
857 pcc->cv.cclasscode = -1;
858 #else
859 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
860 #endif
861 break;
862 case PG_REGEX_LOCALE_ICU:
863 max_chr = (pg_wchar) MAX_SIMPLE_CHR;
864 break;
865 default:
866 max_chr = 0; /* can't get here, but keep compiler quiet */
867 break;
868 }
869
870 /*
871 * And scan 'em ...
872 */
873 nmatches = 0; /* number of consecutive matches */
874
875 for (cur_chr = 0; cur_chr <= max_chr; cur_chr++)
876 {
877 if ((*probefunc) (cur_chr))
878 nmatches++;
879 else if (nmatches > 0)
880 {
881 if (!store_match(pcc, cur_chr - nmatches, nmatches))
882 goto out_of_memory;
883 nmatches = 0;
884 }
885 }
886
887 if (nmatches > 0)
888 if (!store_match(pcc, cur_chr - nmatches, nmatches))
889 goto out_of_memory;
890
891 /*
892 * We might have allocated more memory than needed, if so free it
893 */
894 if (pcc->cv.nchrs == 0)
895 {
896 free(pcc->cv.chrs);
897 pcc->cv.chrs = NULL;
898 pcc->cv.chrspace = 0;
899 }
900 else if (pcc->cv.nchrs < pcc->cv.chrspace)
901 {
902 newchrs = (chr *) realloc(pcc->cv.chrs,
903 pcc->cv.nchrs * sizeof(chr));
904 if (newchrs == NULL)
905 goto out_of_memory;
906 pcc->cv.chrs = newchrs;
907 pcc->cv.chrspace = pcc->cv.nchrs;
908 }
909 if (pcc->cv.nranges == 0)
910 {
911 free(pcc->cv.ranges);
912 pcc->cv.ranges = NULL;
913 pcc->cv.rangespace = 0;
914 }
915 else if (pcc->cv.nranges < pcc->cv.rangespace)
916 {
917 newchrs = (chr *) realloc(pcc->cv.ranges,
918 pcc->cv.nranges * sizeof(chr) * 2);
919 if (newchrs == NULL)
920 goto out_of_memory;
921 pcc->cv.ranges = newchrs;
922 pcc->cv.rangespace = pcc->cv.nranges;
923 }
924
925 /*
926 * Success, link it into cache chain
927 */
928 pcc->next = pg_ctype_cache_list;
929 pg_ctype_cache_list = pcc;
930
931 return &pcc->cv;
932
933 /*
934 * Failure, clean up
935 */
936 out_of_memory:
937 if (pcc->cv.chrs)
938 free(pcc->cv.chrs);
939 if (pcc->cv.ranges)
940 free(pcc->cv.ranges);
941 free(pcc);
942
943 return NULL;
944 }
945