mirror of
https://github.com/postgres/postgres.git
synced 2025-06-30 21:42:05 +03:00
Teach regular expression operators to honor collations.
This involves getting the character classification and case-folding functions in the regex library to use the collations infrastructure. Most of this work had been done already in connection with the upper/lower and LIKE logic, so it was a simple matter of transposition. While at it, split out these functions into a separate source file regc_pg_locale.c, so that they can be correctly labeled with the Postgres project's license rather than the Scriptics license. These functions are 100% Postgres-written code whereas what remains in regc_locale.c is still mostly not ours, so lumping them both under the same copyright notice was getting more and more misleading.
This commit is contained in:
Tom Lane
@ -17,6 +17,7 @@ OBJS = regcomp.o regerror.o regexec.o regfree.o
|
||||
include $(top_srcdir)/src/backend/common.mk
|
||||
|
||||
# mark inclusion dependencies between .c files explicitly
|
||||
regcomp.o: regcomp.c regc_lex.c regc_color.c regc_nfa.c regc_cvec.c regc_locale.c
|
||||
regcomp.o: regcomp.c regc_lex.c regc_color.c regc_nfa.c regc_cvec.c \
|
||||
regc_locale.c regc_pg_locale.c
|
||||
|
||||
regexec.o: regexec.c rege_dfa.c
|
||||
|
||||
@ -350,171 +350,6 @@ static const struct cname
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* ctype functions adapted to work on pg_wchar (a/k/a chr)
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* In all other encodings, 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 relevant for higher code values anyway.
|
||||
*
|
||||
* NB: the coding here assumes pg_wchar is an unsigned type.
|
||||
*/
|
||||
|
||||
static int
|
||||
pg_wc_isdigit(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswdigit((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isdigit((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_isalpha(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswalpha((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isalpha((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_isalnum(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswalnum((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isalnum((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_isupper(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswupper((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isupper((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_islower(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswlower((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && islower((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_isgraph(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswgraph((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isgraph((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_isprint(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswprint((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isprint((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_ispunct(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswpunct((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && ispunct((unsigned char) c));
|
||||
}
|
||||
|
||||
static int
|
||||
pg_wc_isspace(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return iswspace((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
return (c <= (pg_wchar) UCHAR_MAX && isspace((unsigned char) c));
|
||||
}
|
||||
|
||||
static pg_wchar
|
||||
pg_wc_toupper(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return towupper((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
if (c <= (pg_wchar) UCHAR_MAX)
|
||||
return toupper((unsigned char) c);
|
||||
return c;
|
||||
}
|
||||
|
||||
static pg_wchar
|
||||
pg_wc_tolower(pg_wchar c)
|
||||
{
|
||||
#ifdef USE_WIDE_UPPER_LOWER
|
||||
if (GetDatabaseEncoding() == PG_UTF8)
|
||||
{
|
||||
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
|
||||
return towlower((wint_t) c);
|
||||
}
|
||||
#endif
|
||||
if (c <= (pg_wchar) UCHAR_MAX)
|
||||
return tolower((unsigned char) c);
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* element - map collating-element name to celt
|
||||
*/
|
||||
|
||||
649
src/backend/regex/regc_pg_locale.c
Normal file
649
src/backend/regex/regc_pg_locale.c
Normal file
@ -0,0 +1,649 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* 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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
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 */
|
||||
}
|
||||
@ -172,7 +172,7 @@ static void addrange(struct cvec *, chr, chr);
|
||||
static struct cvec *getcvec(struct vars *, int, int);
|
||||
static void freecvec(struct cvec *);
|
||||
|
||||
/* === regc_locale.c === */
|
||||
/* === regc_pg_locale.c === */
|
||||
static int pg_wc_isdigit(pg_wchar c);
|
||||
static int pg_wc_isalpha(pg_wchar c);
|
||||
static int pg_wc_isalnum(pg_wchar c);
|
||||
@ -184,6 +184,8 @@ static int pg_wc_ispunct(pg_wchar c);
|
||||
static int pg_wc_isspace(pg_wchar c);
|
||||
static pg_wchar pg_wc_toupper(pg_wchar c);
|
||||
static pg_wchar pg_wc_tolower(pg_wchar c);
|
||||
|
||||
/* === regc_locale.c === */
|
||||
static celt element(struct vars *, const chr *, const chr *);
|
||||
static struct cvec *range(struct vars *, celt, celt, int);
|
||||
static int before(celt, celt);
|
||||
@ -281,7 +283,8 @@ int
|
||||
pg_regcomp(regex_t *re,
|
||||
const chr *string,
|
||||
size_t len,
|
||||
int flags)
|
||||
int flags,
|
||||
Oid collation)
|
||||
{
|
||||
struct vars var;
|
||||
struct vars *v = &var;
|
||||
@ -307,6 +310,9 @@ pg_regcomp(regex_t *re,
|
||||
if (!(flags & REG_EXTENDED) && (flags & REG_ADVF))
|
||||
return REG_INVARG;
|
||||
|
||||
/* Initialize locale-dependent support */
|
||||
pg_set_regex_collation(collation);
|
||||
|
||||
/* initial setup (after which freev() is callable) */
|
||||
v->re = re;
|
||||
v->now = string;
|
||||
@ -333,6 +339,7 @@ pg_regcomp(regex_t *re,
|
||||
re->re_magic = REMAGIC;
|
||||
re->re_info = 0; /* bits get set during parse */
|
||||
re->re_csize = sizeof(chr);
|
||||
re->re_collation = collation;
|
||||
re->re_guts = NULL;
|
||||
re->re_fns = VS(&functions);
|
||||
|
||||
@ -1987,4 +1994,5 @@ stid(struct subre * t,
|
||||
#include "regc_color.c"
|
||||
#include "regc_nfa.c"
|
||||
#include "regc_cvec.c"
|
||||
#include "regc_pg_locale.c"
|
||||
#include "regc_locale.c"
|
||||
|
||||
@ -192,6 +192,9 @@ pg_regexec(regex_t *re,
|
||||
if (re->re_csize != sizeof(chr))
|
||||
return REG_MIXED;
|
||||
|
||||
/* Initialize locale-dependent support */
|
||||
pg_set_regex_collation(re->re_collation);
|
||||
|
||||
/* setup */
|
||||
v->re = re;
|
||||
v->g = (struct guts *) re->re_guts;
|
||||
|
||||
Reference in New Issue
Block a user