2011-04-11 00:02:17 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* regc_pg_locale.c
|
|
|
|
* ctype functions adapted to work on pg_wchar (a/k/a chr)
|
|
|
|
*
|
|
|
|
* This file is #included by regcomp.c; it's not meant to compile standalone.
|
|
|
|
*
|
|
|
|
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
|
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/backend/regex/regc_pg_locale.c
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "catalog/pg_collation.h"
|
|
|
|
#include "utils/pg_locale.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To provide as much functionality as possible on a variety of platforms,
|
|
|
|
* without going so far as to implement everything from scratch, we use
|
|
|
|
* several implementation strategies depending on the situation:
|
|
|
|
*
|
|
|
|
* 1. In C/POSIX collations, we use hard-wired code. We can't depend on
|
|
|
|
* the <ctype.h> functions since those will obey LC_CTYPE. Note that these
|
|
|
|
* collations don't give a fig about multibyte characters.
|
|
|
|
*
|
|
|
|
* 2. In the "default" collation (which is supposed to obey LC_CTYPE):
|
|
|
|
*
|
|
|
|
* 2a. When working in UTF8 encoding, we use the <wctype.h> functions if
|
|
|
|
* available. This assumes that every platform uses Unicode codepoints
|
|
|
|
* directly as the wchar_t representation of Unicode. On some platforms
|
|
|
|
* wchar_t is only 16 bits wide, so we have to punt for codepoints > 0xFFFF.
|
|
|
|
*
|
|
|
|
* 2b. In all other encodings, or on machines that lack <wctype.h>, we use
|
|
|
|
* the <ctype.h> functions for pg_wchar values up to 255, and punt for values
|
|
|
|
* above that. This is only 100% correct in single-byte encodings such as
|
|
|
|
* LATINn. However, non-Unicode multibyte encodings are mostly Far Eastern
|
|
|
|
* character sets for which the properties being tested here aren't very
|
|
|
|
* relevant for higher code values anyway. The difficulty with using the
|
|
|
|
* <wctype.h> functions with non-Unicode multibyte encodings is that we can
|
|
|
|
* have no certainty that the platform's wchar_t representation matches
|
|
|
|
* what we do in pg_wchar conversions.
|
|
|
|
*
|
|
|
|
* 3. Other collations are only supported on platforms that HAVE_LOCALE_T.
|
|
|
|
* Here, we use the locale_t-extended forms of the <wctype.h> and <ctype.h>
|
|
|
|
* functions, under exactly the same cases as #2.
|
|
|
|
*
|
|
|
|
* There is one notable difference between cases 2 and 3: in the "default"
|
|
|
|
* collation we force ASCII letters to follow ASCII upcase/downcase rules,
|
|
|
|
* while in a non-default collation we just let the library functions do what
|
|
|
|
* they will. The case where this matters is treatment of I/i in Turkish,
|
|
|
|
* and the behavior is meant to match the upper()/lower() SQL functions.
|
|
|
|
*
|
|
|
|
* We store the active collation setting in static variables. In principle
|
|
|
|
* it could be passed down to here via the regex library's "struct vars" data
|
|
|
|
* structure; but that would require somewhat invasive changes in the regex
|
|
|
|
* library, and right now there's no real benefit to be gained from that.
|
|
|
|
*
|
|
|
|
* NB: the coding here assumes pg_wchar is an unsigned type.
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
PG_REGEX_LOCALE_C, /* C locale (encoding independent) */
|
|
|
|
PG_REGEX_LOCALE_WIDE, /* Use <wctype.h> functions */
|
|
|
|
PG_REGEX_LOCALE_1BYTE, /* Use <ctype.h> functions */
|
|
|
|
PG_REGEX_LOCALE_WIDE_L, /* Use locale_t <wctype.h> functions */
|
|
|
|
PG_REGEX_LOCALE_1BYTE_L /* Use locale_t <ctype.h> functions */
|
|
|
|
} PG_Locale_Strategy;
|
|
|
|
|
|
|
|
static PG_Locale_Strategy pg_regex_strategy;
|
|
|
|
static pg_locale_t pg_regex_locale;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hard-wired character properties for C locale
|
|
|
|
*/
|
|
|
|
#define PG_ISDIGIT 0x01
|
|
|
|
#define PG_ISALPHA 0x02
|
|
|
|
#define PG_ISALNUM (PG_ISDIGIT | PG_ISALPHA)
|
|
|
|
#define PG_ISUPPER 0x04
|
|
|
|
#define PG_ISLOWER 0x08
|
|
|
|
#define PG_ISGRAPH 0x10
|
|
|
|
#define PG_ISPRINT 0x20
|
|
|
|
#define PG_ISPUNCT 0x40
|
|
|
|
#define PG_ISSPACE 0x80
|
|
|
|
|
|
|
|
static const unsigned char pg_char_properties[128] = {
|
|
|
|
/* NUL */ 0,
|
|
|
|
/* ^A */ 0,
|
|
|
|
/* ^B */ 0,
|
|
|
|
/* ^C */ 0,
|
|
|
|
/* ^D */ 0,
|
|
|
|
/* ^E */ 0,
|
|
|
|
/* ^F */ 0,
|
|
|
|
/* ^G */ 0,
|
|
|
|
/* ^H */ 0,
|
|
|
|
/* ^I */ PG_ISSPACE,
|
|
|
|
/* ^J */ PG_ISSPACE,
|
|
|
|
/* ^K */ PG_ISSPACE,
|
|
|
|
/* ^L */ PG_ISSPACE,
|
|
|
|
/* ^M */ PG_ISSPACE,
|
|
|
|
/* ^N */ 0,
|
|
|
|
/* ^O */ 0,
|
|
|
|
/* ^P */ 0,
|
|
|
|
/* ^Q */ 0,
|
|
|
|
/* ^R */ 0,
|
|
|
|
/* ^S */ 0,
|
|
|
|
/* ^T */ 0,
|
|
|
|
/* ^U */ 0,
|
|
|
|
/* ^V */ 0,
|
|
|
|
/* ^W */ 0,
|
|
|
|
/* ^X */ 0,
|
|
|
|
/* ^Y */ 0,
|
|
|
|
/* ^Z */ 0,
|
|
|
|
/* ^[ */ 0,
|
|
|
|
/* ^\ */ 0,
|
|
|
|
/* ^] */ 0,
|
|
|
|
/* ^^ */ 0,
|
|
|
|
/* ^_ */ 0,
|
|
|
|
/* */ PG_ISPRINT | PG_ISSPACE,
|
|
|
|
/* ! */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* " */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* # */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* $ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* % */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* & */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ' */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ( */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ) */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* * */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* + */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* , */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* - */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* . */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* / */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* 0 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 1 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 2 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 3 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 4 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 5 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 6 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 7 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 8 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* 9 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* : */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ; */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* < */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* = */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* > */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ? */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* @ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* A */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* B */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* C */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* D */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* E */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* F */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* G */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* H */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* I */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* J */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* K */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* L */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* M */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* N */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* O */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* P */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* Q */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* R */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* S */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* T */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* U */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* V */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* W */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* X */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* Y */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* Z */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* [ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* \ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ] */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ^ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* _ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ` */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* a */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* b */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* c */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* d */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* e */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* f */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* g */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* h */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* i */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* j */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* k */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* l */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* m */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* n */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* o */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* p */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* q */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* r */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* s */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* t */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* u */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* v */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* w */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* x */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* y */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* z */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT,
|
|
|
|
/* { */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* | */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* } */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* ~ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT,
|
|
|
|
/* DEL */ 0
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pg_set_regex_collation: set collation for these functions to obey
|
|
|
|
*
|
|
|
|
* This is called when beginning compilation or execution of a regexp.
|
|
|
|
* Since there's no need for re-entrancy of regexp operations, it's okay
|
|
|
|
* to store the results in static variables.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
pg_set_regex_collation(Oid collation)
|
|
|
|
{
|
|
|
|
if (lc_ctype_is_c(collation))
|
|
|
|
{
|
|
|
|
/* C/POSIX collations use this path regardless of database encoding */
|
|
|
|
pg_regex_strategy = PG_REGEX_LOCALE_C;
|
|
|
|
pg_regex_locale = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (collation == DEFAULT_COLLATION_OID)
|
|
|
|
pg_regex_locale = 0;
|
|
|
|
else if (OidIsValid(collation))
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* NB: pg_newlocale_from_collation will fail if not HAVE_LOCALE_T;
|
|
|
|
* the case of pg_regex_locale != 0 but not HAVE_LOCALE_T does
|
|
|
|
* not have to be considered below.
|
|
|
|
*/
|
|
|
|
pg_regex_locale = pg_newlocale_from_collation(collation);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This typically means that the parser could not resolve a
|
|
|
|
* conflict of implicit collations, so report it that way.
|
|
|
|
*/
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INDETERMINATE_COLLATION),
|
|
|
|
errmsg("could not determine which collation to use for regular expression"),
|
|
|
|
errhint("Use the COLLATE clause to set the collation explicitly.")));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (GetDatabaseEncoding() == PG_UTF8)
|
|
|
|
{
|
|
|
|
if (pg_regex_locale)
|
|
|
|
pg_regex_strategy = PG_REGEX_LOCALE_WIDE_L;
|
|
|
|
else
|
|
|
|
pg_regex_strategy = PG_REGEX_LOCALE_WIDE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif /* USE_WIDE_UPPER_LOWER */
|
|
|
|
{
|
|
|
|
if (pg_regex_locale)
|
|
|
|
pg_regex_strategy = PG_REGEX_LOCALE_1BYTE_L;
|
|
|
|
else
|
|
|
|
pg_regex_strategy = PG_REGEX_LOCALE_1BYTE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isdigit(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISDIGIT));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswdigit((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isdigit((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswdigit_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isdigit_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isalpha(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISALPHA));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswalpha((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isalpha((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswalpha_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isalpha_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isalnum(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISALNUM));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswalnum((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isalnum((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswalnum_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isalnum_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isupper(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISUPPER));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswupper((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isupper((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswupper_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isupper_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_islower(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISLOWER));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswlower((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
islower((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswlower_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
islower_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isgraph(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISGRAPH));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswgraph((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isgraph((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswgraph_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isgraph_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isprint(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISPRINT));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswprint((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isprint((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswprint_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isprint_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_ispunct(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISPUNCT));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswpunct((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
ispunct((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswpunct_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
ispunct_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pg_wc_isspace(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
return (c <= (pg_wchar) 127 &&
|
|
|
|
(pg_char_properties[c] & PG_ISSPACE));
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswspace((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isspace((unsigned char) c));
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return iswspace_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
return (c <= (pg_wchar) UCHAR_MAX &&
|
|
|
|
isspace_l((unsigned char) c, pg_regex_locale));
|
|
|
|
#endif
|
2011-04-11 00:44:07 +02:00
|
|
|
break;
|
2011-04-11 00:02:17 +02:00
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static pg_wchar
|
|
|
|
pg_wc_toupper(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
if (c <= (pg_wchar) 127)
|
|
|
|
return pg_ascii_toupper((unsigned char) c);
|
|
|
|
return c;
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
/* force C behavior for ASCII characters, per comments above */
|
|
|
|
if (c <= (pg_wchar) 127)
|
|
|
|
return pg_ascii_toupper((unsigned char) c);
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return towupper((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
/* force C behavior for ASCII characters, per comments above */
|
|
|
|
if (c <= (pg_wchar) 127)
|
|
|
|
return pg_ascii_toupper((unsigned char) c);
|
|
|
|
if (c <= (pg_wchar) UCHAR_MAX)
|
|
|
|
return toupper((unsigned char) c);
|
|
|
|
return c;
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return towupper_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
if (c <= (pg_wchar) UCHAR_MAX)
|
|
|
|
return toupper_l((unsigned char) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|
|
|
|
|
|
|
|
static pg_wchar
|
|
|
|
pg_wc_tolower(pg_wchar c)
|
|
|
|
{
|
|
|
|
switch (pg_regex_strategy)
|
|
|
|
{
|
|
|
|
case PG_REGEX_LOCALE_C:
|
|
|
|
if (c <= (pg_wchar) 127)
|
|
|
|
return pg_ascii_tolower((unsigned char) c);
|
|
|
|
return c;
|
|
|
|
case PG_REGEX_LOCALE_WIDE:
|
|
|
|
/* force C behavior for ASCII characters, per comments above */
|
|
|
|
if (c <= (pg_wchar) 127)
|
|
|
|
return pg_ascii_tolower((unsigned char) c);
|
|
|
|
#ifdef USE_WIDE_UPPER_LOWER
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return towlower((wint_t) c);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE:
|
|
|
|
/* force C behavior for ASCII characters, per comments above */
|
|
|
|
if (c <= (pg_wchar) 127)
|
|
|
|
return pg_ascii_tolower((unsigned char) c);
|
|
|
|
if (c <= (pg_wchar) UCHAR_MAX)
|
|
|
|
return tolower((unsigned char) c);
|
|
|
|
return c;
|
|
|
|
case PG_REGEX_LOCALE_WIDE_L:
|
|
|
|
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
|
|
|
|
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
|
|
|
return towlower_l((wint_t) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
/* FALL THRU */
|
|
|
|
case PG_REGEX_LOCALE_1BYTE_L:
|
|
|
|
#ifdef HAVE_LOCALE_T
|
|
|
|
if (c <= (pg_wchar) UCHAR_MAX)
|
|
|
|
return tolower_l((unsigned char) c, pg_regex_locale);
|
|
|
|
#endif
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
return 0; /* can't get here, but keep compiler quiet */
|
|
|
|
}
|