pg_locale_libc.c File Reference

#include "postgres.h"
#include <limits.h>
#include <wctype.h>
#include "access/htup_details.h"
#include "catalog/pg_database.h"
#include "catalog/pg_collation.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/formatting.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/syscache.h"

Include dependency graph for pg_locale_libc.c:

Go to the source code of this file.

Macros
#define	TEXTBUFLEN   1024

Functions
pg_locale_t	create_pg_locale_libc (Oid collid, MemoryContext context)
static int	strncoll_libc (const char *arg1, size_t len1, const char *arg2, size_t len2, pg_locale_t locale)
static int	strcoll_libc (const char *arg1, const char *arg2, pg_locale_t locale)
static size_t	strnxfrm_libc (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t	strxfrm_libc (char *dest, size_t destsize, const char *src, pg_locale_t locale)
char *	get_collation_actual_version_libc (const char *collcollate)
static locale_t	make_libc_collator (const char *collate, const char *ctype)
static size_t	char2wchar (wchar_t *to, size_t tolen, const char *from, size_t fromlen, locale_t loc)
static size_t	strlower_libc_sb (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t	strlower_libc_mb (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t	strtitle_libc_sb (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t	strtitle_libc_mb (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t	strupper_libc_sb (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t	strupper_libc_mb (char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static bool	wc_isdigit_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isalpha_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isalnum_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isupper_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_islower_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isgraph_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isprint_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_ispunct_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isspace_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isxdigit_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_iscased_libc_sb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isdigit_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isalpha_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isalnum_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isupper_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_islower_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isgraph_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isprint_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_ispunct_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isspace_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_isxdigit_libc_mb (pg_wchar wc, pg_locale_t locale)
static bool	wc_iscased_libc_mb (pg_wchar wc, pg_locale_t locale)
static pg_wchar	toupper_libc_sb (pg_wchar wc, pg_locale_t locale)
static pg_wchar	toupper_libc_mb (pg_wchar wc, pg_locale_t locale)
static pg_wchar	tolower_libc_sb (pg_wchar wc, pg_locale_t locale)
static pg_wchar	tolower_libc_mb (pg_wchar wc, pg_locale_t locale)
static size_t	downcase_ident_libc_sb (char *dst, size_t dstsize, const char *src, size_t srclen, pg_locale_t locale)
void	report_newlocale_failure (const char *localename)
static size_t	mbstowcs_l (wchar_t *dest, const char *src, size_t n, locale_t loc)
static size_t	wcstombs_l (char *dest, const wchar_t *src, size_t n, locale_t loc)
size_t	wchar2char (char *to, const wchar_t *from, size_t tolen, locale_t loc)

Variables
static const struct ctype_methods	ctype_methods_libc_sb
static const struct ctype_methods	ctype_methods_libc_other_mb
static const struct ctype_methods	ctype_methods_libc_utf8
static const struct collate_methods	collate_methods_libc

Macro Definition Documentation

TEXTBUFLEN

#define TEXTBUFLEN   1024

Definition at line 81 of file pg_locale_libc.c.

Function Documentation

char2wchar()

static size_t char2wchar ( wchar_t *  to, size_t  tolen, const char *  from, size_t  fromlen, locale_t  loc  )

static

Definition at line 1258 of file pg_locale_libc.c.

{
    size_t      result;
 
    if (tolen == 0)
        return 0;
 
#ifdef WIN32
    /* See WIN32 "Unicode" comment above */
    if (GetDatabaseEncoding() == PG_UTF8)
    {
        /* Win32 API does not work for zero-length input */
        if (fromlen == 0)
            result = 0;
        else
        {
            result = MultiByteToWideChar(CP_UTF8, 0, from, fromlen, to, tolen - 1);
            /* A zero return is failure */
            if (result == 0)
                result = -1;
        }
 
        if (result != -1)
        {
            Assert(result < tolen);
            /* Append trailing null wchar (MultiByteToWideChar() does not) */
            to[result] = 0;
        }
    }
    else
#endif                          /* WIN32 */
    {
        /* mbstowcs requires ending '\0' */
        char       *str = pnstrdup(from, fromlen);
 
        if (loc == (locale_t) 0)
        {
            /* Use mbstowcs directly for the default locale */
            result = mbstowcs(to, str, tolen);
        }
        else
        {
            /* Use mbstowcs_l for nondefault locales */
            result = mbstowcs_l(to, str, tolen, loc);
        }
 
        pfree(str);
    }
 
    if (result == -1)
    {
        /*
         * Invalid multibyte character encountered.  We try to give a useful
         * error message by letting pg_verifymbstr check the string.  But it's
         * possible that the string is OK to us, and not OK to mbstowcs ---
         * this suggests that the LC_CTYPE locale is different from the
         * database encoding.  Give a generic error message if pg_verifymbstr
         * can't find anything wrong.
         */
        pg_verifymbstr(from, fromlen, false);   /* might not return */
        /* but if it does ... */
        ereport(ERROR,
                (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
                 errmsg("invalid multibyte character for locale"),
                 errhint("The server's LC_CTYPE locale is probably incompatible with the database encoding.")));
    }
 
    return result;
}

References Assert, ereport, errcode(), errhint(), errmsg, ERROR, fb(), GetDatabaseEncoding(), locale_t, mbstowcs_l(), pfree(), PG_UTF8, pg_verifymbstr(), pnstrdup(), result, and str.

Referenced by strlower_libc_mb(), strtitle_libc_mb(), and strupper_libc_mb().

create_pg_locale_libc()

pg_locale_t create_pg_locale_libc ( Oid  collid, MemoryContext  context  )

extern

Definition at line 734 of file pg_locale_libc.c.

{
    const char *collate;
    const char *ctype;
    locale_t    loc;
    pg_locale_t result;
 
    if (collid == DEFAULT_COLLATION_OID)
    {
        HeapTuple   tp;
        Datum       datum;
 
        tp = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
        datum = SysCacheGetAttrNotNull(DATABASEOID, tp,
                                       Anum_pg_database_datcollate);
        collate = TextDatumGetCString(datum);
        datum = SysCacheGetAttrNotNull(DATABASEOID, tp,
                                       Anum_pg_database_datctype);
        ctype = TextDatumGetCString(datum);
 
        ReleaseSysCache(tp);
    }
    else
    {
        HeapTuple   tp;
        Datum       datum;
 
        tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for collation %u", collid);
 
        datum = SysCacheGetAttrNotNull(COLLOID, tp,
                                       Anum_pg_collation_collcollate);
        collate = TextDatumGetCString(datum);
        datum = SysCacheGetAttrNotNull(COLLOID, tp,
                                       Anum_pg_collation_collctype);
        ctype = TextDatumGetCString(datum);
 
        ReleaseSysCache(tp);
    }
 
 
    loc = make_libc_collator(collate, ctype);
 
    result = MemoryContextAllocZero(context, sizeof(struct pg_locale_struct));
    result->deterministic = true;
    result->collate_is_c = (strcmp(collate, "C") == 0) ||
        (strcmp(collate, "POSIX") == 0);
    result->ctype_is_c = (strcmp(ctype, "C") == 0) ||
        (strcmp(ctype, "POSIX") == 0);
    result->lt = loc;
    if (!result->collate_is_c)
    {
#ifdef WIN32
        if (GetDatabaseEncoding() == PG_UTF8)
            result->collate = &collate_methods_libc_win32_utf8;
        else
#endif
            result->collate = &collate_methods_libc;
    }
    if (!result->ctype_is_c)
    {
        if (GetDatabaseEncoding() == PG_UTF8)
            result->ctype = &ctype_methods_libc_utf8;
        else if (pg_database_encoding_max_length() > 1)
            result->ctype = &ctype_methods_libc_other_mb;
        else
            result->ctype = &ctype_methods_libc_sb;
    }
 
    return result;
}

References collate_methods_libc, collid, ctype_methods_libc_other_mb, ctype_methods_libc_sb, ctype_methods_libc_utf8, elog, ERROR, fb(), GetDatabaseEncoding(), HeapTupleIsValid, locale_t, make_libc_collator(), MemoryContextAllocZero(), MyDatabaseId, ObjectIdGetDatum(), pg_database_encoding_max_length(), PG_UTF8, ReleaseSysCache(), result, SearchSysCache1(), SysCacheGetAttrNotNull(), and TextDatumGetCString.

Referenced by create_pg_locale(), and init_database_collation().

downcase_ident_libc_sb()

static size_t downcase_ident_libc_sb ( char *  dst, size_t  dstsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 332 of file pg_locale_libc.c.

{
    locale_t    loc = locale->lt;
    int         i;
 
    for (i = 0; i < srclen && i < dstsize; i++)
    {
        unsigned char ch = (unsigned char) src[i];
 
        if (ch >= 'A' && ch <= 'Z')
            ch = pg_ascii_tolower(ch);
        else if (IS_HIGHBIT_SET(ch) && isupper_l(ch, loc))
            ch = tolower_l(ch, loc);
        dst[i] = (char) ch;
    }
 
    if (i < dstsize)
        dst[i] = '\0';
 
    return srclen;
}

References fb(), i, IS_HIGHBIT_SET, isupper_l, locale_t, pg_locale_struct::lt, pg_ascii_tolower(), and tolower_l.

get_collation_actual_version_libc()

char * get_collation_actual_version_libc ( const char *  collcollate )

extern

Definition at line 973 of file pg_locale_libc.c.

{
    char       *collversion = NULL;
 
    if (pg_strcasecmp("C", collcollate) != 0 &&
        pg_strncasecmp("C.", collcollate, 2) != 0 &&
        pg_strcasecmp("POSIX", collcollate) != 0)
    {
#if defined(__GLIBC__)
        /* Use the glibc version because we don't have anything better. */
        collversion = pstrdup(gnu_get_libc_version());
#elif defined(LC_VERSION_MASK)
        locale_t    loc;
 
        /* Look up FreeBSD collation version. */
        loc = newlocale(LC_COLLATE_MASK, collcollate, NULL);
        if (loc)
        {
            collversion =
                pstrdup(querylocale(LC_COLLATE_MASK | LC_VERSION_MASK, loc));
            freelocale(loc);
        }
        else
            ereport(ERROR,
                    (errmsg("could not load locale \"%s\"", collcollate)));
#elif defined(WIN32)
        /*
         * If we are targeting Windows Vista and above, we can ask for a name
         * given a collation name (earlier versions required a location code
         * that we don't have).
         */
        NLSVERSIONINFOEX version = {sizeof(NLSVERSIONINFOEX)};
        WCHAR       wide_collcollate[LOCALE_NAME_MAX_LENGTH];
 
        MultiByteToWideChar(CP_ACP, 0, collcollate, -1, wide_collcollate,
                            LOCALE_NAME_MAX_LENGTH);
        if (!GetNLSVersionEx(COMPARE_STRING, wide_collcollate, &version))
        {
            /*
             * GetNLSVersionEx() wants a language tag such as "en-US", not a
             * locale name like "English_United States.1252".  Until those
             * values can be prevented from entering the system, or 100%
             * reliably converted to the more useful tag format, tolerate the
             * resulting error and report that we have no version data.
             */
            if (GetLastError() == ERROR_INVALID_PARAMETER)
                return NULL;
 
            ereport(ERROR,
                    (errmsg("could not get collation version for locale \"%s\": error code %lu",
                            collcollate,
                            GetLastError())));
        }
        collversion = psprintf("%lu.%lu,%lu.%lu",
                               (version.dwNLSVersion >> 8) & 0xFFFF,
                               version.dwNLSVersion & 0xFF,
                               (version.dwDefinedVersion >> 8) & 0xFFFF,
                               version.dwDefinedVersion & 0xFF);
#endif
    }
 
    return collversion;
}

References ereport, errmsg, ERROR, fb(), locale_t, pg_strcasecmp(), pg_strncasecmp(), psprintf(), and pstrdup().

Referenced by get_collation_actual_version().

make_libc_collator()

static locale_t make_libc_collator ( const char *  collate, const char *  ctype  )

static

Definition at line 818 of file pg_locale_libc.c.

{
    locale_t    loc = 0;
 
    if (strcmp(collate, ctype) == 0)
    {
        if (strcmp(ctype, "C") != 0 && strcmp(ctype, "POSIX") != 0)
        {
            /* Normal case where they're the same */
            errno = 0;
#ifndef WIN32
            loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collate,
                            NULL);
#else
            loc = _create_locale(LC_ALL, collate);
#endif
            if (!loc)
                report_newlocale_failure(collate);
        }
    }
    else
    {
#ifndef WIN32
        /* We need two newlocale() steps */
        locale_t    loc1 = 0;
 
        if (strcmp(collate, "C") != 0 && strcmp(collate, "POSIX") != 0)
        {
            errno = 0;
            loc1 = newlocale(LC_COLLATE_MASK, collate, NULL);
            if (!loc1)
                report_newlocale_failure(collate);
        }
 
        if (strcmp(ctype, "C") != 0 && strcmp(ctype, "POSIX") != 0)
        {
            errno = 0;
            loc = newlocale(LC_CTYPE_MASK, ctype, loc1);
            if (!loc)
            {
                if (loc1)
                    freelocale(loc1);
                report_newlocale_failure(ctype);
            }
        }
        else
            loc = loc1;
#else
 
        /*
         * XXX The _create_locale() API doesn't appear to support this. Could
         * perhaps be worked around by changing pg_locale_t to contain two
         * separate fields.
         */
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("collations with different collate and ctype values are not supported on this platform")));
#endif
    }
 
    return loc;
}

References ereport, errcode(), errmsg, ERROR, fb(), locale_t, and report_newlocale_failure().

Referenced by create_pg_locale_libc().

mbstowcs_l()

static size_t mbstowcs_l ( wchar_t *  dest, const char *  src, size_t  n, locale_t  loc  )

static

Definition at line 1160 of file pg_locale_libc.c.

{
#ifdef WIN32
    return _mbstowcs_l(dest, src, n, loc);
#else
    size_t      result;
    locale_t    save_locale = uselocale(loc);
 
    result = mbstowcs(dest, src, n);
    uselocale(save_locale);
    return result;
#endif
}

References fb(), locale_t, and result.

Referenced by char2wchar().

report_newlocale_failure()

void report_newlocale_failure

(

const char *

localename

)

Definition at line 1126 of file pg_locale_libc.c.

{
    int         save_errno;
 
    /*
     * Windows doesn't provide any useful error indication from
     * _create_locale(), and BSD-derived platforms don't seem to feel they
     * need to set errno either (even though POSIX is pretty clear that
     * newlocale should do so).  So, if errno hasn't been set, assume ENOENT
     * is what to report.
     */
    if (errno == 0)
        errno = ENOENT;
 
    /*
     * ENOENT means "no such locale", not "no such file", so clarify that
     * errno with an errdetail message.
     */
    save_errno = errno;         /* auxiliary funcs might change errno */
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("could not create locale \"%s\": %m",
                    localename),
             (save_errno == ENOENT ?
              errdetail("The operating system could not find any locale data for the locale name \"%s\".",
                        localename) : 0)));
}

References ereport, errcode(), errdetail(), errmsg, ERROR, and fb().

Referenced by cache_locale_time(), and make_libc_collator().

strcoll_libc()

static int strcoll_libc ( const char *  arg1, const char *  arg2, pg_locale_t  locale  )

static

Definition at line 926 of file pg_locale_libc.c.

{
    return strcoll_l(arg1, arg2, locale->lt);
}

References fb(), pg_locale_struct::lt, and strcoll_l.

strlower_libc_mb()

static size_t strlower_libc_mb ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 503 of file pg_locale_libc.c.

{
    locale_t    loc = locale->lt;
    size_t      result_size;
    wchar_t    *workspace;
    char       *result;
    size_t      curr_char;
    size_t      max_size;
 
    /* Overflow paranoia */
    if ((srclen + 1) > (INT_MAX / sizeof(wchar_t)))
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
 
    /* Output workspace cannot have more codes than input bytes */
    workspace = palloc_array(wchar_t, srclen + 1);
 
    char2wchar(workspace, srclen + 1, src, srclen, loc);
 
    for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
        workspace[curr_char] = towlower_l(workspace[curr_char], loc);
 
    /*
     * Make result large enough; case change might change number of bytes
     */
    max_size = curr_char * pg_database_encoding_max_length();
    result = palloc(max_size + 1);
 
    result_size = wchar2char(result, workspace, max_size + 1, loc);
 
    if (destsize >= result_size + 1)
    {
        memcpy(dest, result, result_size);
        dest[result_size] = '\0';
    }
 
    pfree(workspace);
    pfree(result);
 
    return result_size;
}

References char2wchar(), ereport, errcode(), errmsg, ERROR, fb(), locale_t, pg_locale_struct::lt, memcpy(), palloc(), palloc_array, pfree(), pg_database_encoding_max_length(), result, towlower_l, and wchar2char().

strlower_libc_sb()

static size_t strlower_libc_sb ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 467 of file pg_locale_libc.c.

{
    if (srclen + 1 <= destsize)
    {
        locale_t    loc = locale->lt;
        char       *p;
 
        memcpy(dest, src, srclen);
        dest[srclen] = '\0';
 
        /*
         * Note: we assume that tolower_l() will not be so broken as to need
         * an isupper_l() guard test.  When using the default collation, we
         * apply the traditional Postgres behavior that forces ASCII-style
         * treatment of I/i, but in non-default collations you get exactly
         * what the collation says.
         */
        for (p = dest; *p; p++)
        {
            if (locale->is_default)
            {
                if (*p >= 'A' && *p <= 'Z')
                    *p += 'a' - 'A';
                else if (IS_HIGHBIT_SET(*p) && isupper_l(*p, loc))
                    *p = tolower_l((unsigned char) *p, loc);
            }
            else
                *p = tolower_l((unsigned char) *p, loc);
        }
    }
 
    return srclen;
}

References fb(), pg_locale_struct::is_default, IS_HIGHBIT_SET, isupper_l, locale_t, pg_locale_struct::lt, memcpy(), and tolower_l.

strncoll_libc()

static int strncoll_libc ( const char *  arg1, size_t  len1, const char *  arg2, size_t  len2, pg_locale_t  locale  )

static

Definition at line 887 of file pg_locale_libc.c.

{
    char        sbuf[TEXTBUFLEN];
    char       *buf = sbuf;
    size_t      bufsize1 = len1 + 1;
    size_t      bufsize2 = len2 + 1;
    char       *buf1;
    char       *buf2;
    const char *arg1n;
    const char *arg2n;
    int         result;
 
    if (bufsize1 + bufsize2 > TEXTBUFLEN)
        buf = palloc(bufsize1 + bufsize2);
 
    buf1 = buf;
    buf2 = buf + bufsize1;
 
    memcpy(buf1, arg1, len1);
    buf1[len1] = '\0';
    arg1n = buf1;
 
    memcpy(buf2, arg2, len2);
    buf2[len2] = '\0';
    arg2n = buf2;
 
    result = strcoll_l(arg1n, arg2n, locale->lt);
 
    if (buf != sbuf)
        pfree(buf);
 
    return result;
}

References buf, fb(), pg_locale_struct::lt, memcpy(), palloc(), pfree(), result, strcoll_l, and TEXTBUFLEN.

strnxfrm_libc()

static size_t strnxfrm_libc ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 937 of file pg_locale_libc.c.

{
    char        sbuf[TEXTBUFLEN];
    char       *buf = sbuf;
    size_t      bufsize = srclen + 1;
    size_t      result;
 
    if (bufsize > TEXTBUFLEN)
        buf = palloc(bufsize);
 
    /* nul-terminate argument */
    memcpy(buf, src, srclen);
    buf[srclen] = '\0';
 
    result = strxfrm_l(dest, buf, destsize, locale->lt);
 
    if (buf != sbuf)
        pfree(buf);
 
    /* if dest is defined, it should be nul-terminated */
    Assert(result >= destsize || dest[result] == '\0');
 
    return result;
}

References Assert, buf, bufsize, fb(), pg_locale_struct::lt, memcpy(), palloc(), pfree(), result, strxfrm_l, and TEXTBUFLEN.

strtitle_libc_mb()

static size_t strtitle_libc_mb ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 601 of file pg_locale_libc.c.

{
    locale_t    loc = locale->lt;
    int         wasalnum = false;
    size_t      result_size;
    wchar_t    *workspace;
    char       *result;
    size_t      curr_char;
    size_t      max_size;
 
    /* Overflow paranoia */
    if ((srclen + 1) > (INT_MAX / sizeof(wchar_t)))
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
 
    /* Output workspace cannot have more codes than input bytes */
    workspace = palloc_array(wchar_t, srclen + 1);
 
    char2wchar(workspace, srclen + 1, src, srclen, loc);
 
    for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
    {
        if (wasalnum)
            workspace[curr_char] = towlower_l(workspace[curr_char], loc);
        else
            workspace[curr_char] = towupper_l(workspace[curr_char], loc);
        wasalnum = iswalnum_l(workspace[curr_char], loc);
    }
 
    /*
     * Make result large enough; case change might change number of bytes
     */
    max_size = curr_char * pg_database_encoding_max_length();
    result = palloc(max_size + 1);
 
    result_size = wchar2char(result, workspace, max_size + 1, loc);
 
    if (destsize >= result_size + 1)
    {
        memcpy(dest, result, result_size);
        dest[result_size] = '\0';
    }
 
    pfree(workspace);
    pfree(result);
 
    return result_size;
}

References char2wchar(), ereport, errcode(), errmsg, ERROR, fb(), iswalnum_l, locale_t, pg_locale_struct::lt, memcpy(), palloc(), palloc_array, pfree(), pg_database_encoding_max_length(), result, towlower_l, towupper_l, and wchar2char().

strtitle_libc_sb()

static size_t strtitle_libc_sb ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 548 of file pg_locale_libc.c.

{
    if (srclen + 1 <= destsize)
    {
        locale_t    loc = locale->lt;
        int         wasalnum = false;
        char       *p;
 
        memcpy(dest, src, srclen);
        dest[srclen] = '\0';
 
        /*
         * Note: we assume that toupper_l()/tolower_l() will not be so broken
         * as to need guard tests.  When using the default collation, we apply
         * the traditional Postgres behavior that forces ASCII-style treatment
         * of I/i, but in non-default collations you get exactly what the
         * collation says.
         */
        for (p = dest; *p; p++)
        {
            if (locale->is_default)
            {
                if (wasalnum)
                {
                    if (*p >= 'A' && *p <= 'Z')
                        *p += 'a' - 'A';
                    else if (IS_HIGHBIT_SET(*p) && isupper_l(*p, loc))
                        *p = tolower_l((unsigned char) *p, loc);
                }
                else
                {
                    if (*p >= 'a' && *p <= 'z')
                        *p -= 'a' - 'A';
                    else if (IS_HIGHBIT_SET(*p) && islower_l(*p, loc))
                        *p = toupper_l((unsigned char) *p, loc);
                }
            }
            else
            {
                if (wasalnum)
                    *p = tolower_l((unsigned char) *p, loc);
                else
                    *p = toupper_l((unsigned char) *p, loc);
            }
            wasalnum = isalnum_l((unsigned char) *p, loc);
        }
    }
 
    return srclen;
}

References fb(), pg_locale_struct::is_default, IS_HIGHBIT_SET, isalnum_l, islower_l, isupper_l, locale_t, pg_locale_struct::lt, memcpy(), tolower_l, and toupper_l.

strupper_libc_mb()

static size_t strupper_libc_mb ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 689 of file pg_locale_libc.c.

{
    locale_t    loc = locale->lt;
    size_t      result_size;
    wchar_t    *workspace;
    char       *result;
    size_t      curr_char;
    size_t      max_size;
 
    /* Overflow paranoia */
    if ((srclen + 1) > (INT_MAX / sizeof(wchar_t)))
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
 
    /* Output workspace cannot have more codes than input bytes */
    workspace = palloc_array(wchar_t, srclen + 1);
 
    char2wchar(workspace, srclen + 1, src, srclen, loc);
 
    for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
        workspace[curr_char] = towupper_l(workspace[curr_char], loc);
 
    /*
     * Make result large enough; case change might change number of bytes
     */
    max_size = curr_char * pg_database_encoding_max_length();
    result = palloc(max_size + 1);
 
    result_size = wchar2char(result, workspace, max_size + 1, loc);
 
    if (destsize >= result_size + 1)
    {
        memcpy(dest, result, result_size);
        dest[result_size] = '\0';
    }
 
    pfree(workspace);
    pfree(result);
 
    return result_size;
}

References char2wchar(), ereport, errcode(), errmsg, ERROR, fb(), locale_t, pg_locale_struct::lt, memcpy(), palloc(), palloc_array, pfree(), pg_database_encoding_max_length(), result, towupper_l, and wchar2char().

strupper_libc_sb()

static size_t strupper_libc_sb ( char *  dest, size_t  destsize, const char *  src, size_t  srclen, pg_locale_t  locale  )

static

Definition at line 653 of file pg_locale_libc.c.

{
    if (srclen + 1 <= destsize)
    {
        locale_t    loc = locale->lt;
        char       *p;
 
        memcpy(dest, src, srclen);
        dest[srclen] = '\0';
 
        /*
         * Note: we assume that toupper_l() will not be so broken as to need
         * an islower_l() guard test.  When using the default collation, we
         * apply the traditional Postgres behavior that forces ASCII-style
         * treatment of I/i, but in non-default collations you get exactly
         * what the collation says.
         */
        for (p = dest; *p; p++)
        {
            if (locale->is_default)
            {
                if (*p >= 'a' && *p <= 'z')
                    *p -= 'a' - 'A';
                else if (IS_HIGHBIT_SET(*p) && islower_l(*p, loc))
                    *p = toupper_l((unsigned char) *p, loc);
            }
            else
                *p = toupper_l((unsigned char) *p, loc);
        }
    }
 
    return srclen;
}

References fb(), pg_locale_struct::is_default, IS_HIGHBIT_SET, islower_l, locale_t, pg_locale_struct::lt, memcpy(), and toupper_l.

strxfrm_libc()

static size_t strxfrm_libc ( char *  dest, size_t  destsize, const char *  src, pg_locale_t  locale  )

static

Definition at line 967 of file pg_locale_libc.c.

{
    return strxfrm_l(dest, src, destsize, locale->lt);
}

References fb(), pg_locale_struct::lt, and strxfrm_l.

tolower_libc_mb()

static pg_wchar tolower_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 314 of file pg_locale_libc.c.

{
    Assert(GetDatabaseEncoding() == PG_UTF8);
 
    /* force C behavior for ASCII characters, per comments above */
    if (locale->is_default && wc <= (pg_wchar) 127)
        return pg_ascii_tolower((unsigned char) wc);
    if (sizeof(wchar_t) >= 4 || wc <= (pg_wchar) 0xFFFF)
        return towlower_l((wint_t) wc, locale->lt);
    else
        return wc;
}

References Assert, fb(), GetDatabaseEncoding(), pg_locale_struct::is_default, pg_locale_struct::lt, pg_ascii_tolower(), PG_UTF8, and towlower_l.

tolower_libc_sb()

static pg_wchar tolower_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 300 of file pg_locale_libc.c.

{
    Assert(GetDatabaseEncoding() != PG_UTF8);
 
    /* force C behavior for ASCII characters, per comments above */
    if (locale->is_default && wc <= (pg_wchar) 127)
        return pg_ascii_tolower((unsigned char) wc);
    if (wc <= (pg_wchar) UCHAR_MAX)
        return tolower_l((unsigned char) wc, locale->lt);
    else
        return wc;
}

References Assert, fb(), GetDatabaseEncoding(), pg_locale_struct::is_default, pg_locale_struct::lt, pg_ascii_tolower(), PG_UTF8, and tolower_l.

toupper_libc_mb()

static pg_wchar toupper_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 286 of file pg_locale_libc.c.

{
    Assert(GetDatabaseEncoding() == PG_UTF8);
 
    /* force C behavior for ASCII characters, per comments above */
    if (locale->is_default && wc <= (pg_wchar) 127)
        return pg_ascii_toupper((unsigned char) wc);
    if (sizeof(wchar_t) >= 4 || wc <= (pg_wchar) 0xFFFF)
        return towupper_l((wint_t) wc, locale->lt);
    else
        return wc;
}

References Assert, fb(), GetDatabaseEncoding(), pg_locale_struct::is_default, pg_locale_struct::lt, pg_ascii_toupper(), PG_UTF8, and towupper_l.

toupper_libc_sb()

static pg_wchar toupper_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 272 of file pg_locale_libc.c.

{
    Assert(GetDatabaseEncoding() != PG_UTF8);
 
    /* force C behavior for ASCII characters, per comments above */
    if (locale->is_default && wc <= (pg_wchar) 127)
        return pg_ascii_toupper((unsigned char) wc);
    if (wc <= (pg_wchar) UCHAR_MAX)
        return toupper_l((unsigned char) wc, locale->lt);
    else
        return wc;
}

References Assert, fb(), GetDatabaseEncoding(), pg_locale_struct::is_default, pg_locale_struct::lt, pg_ascii_toupper(), PG_UTF8, and toupper_l.

wc_isalnum_libc_mb()

static bool wc_isalnum_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 213 of file pg_locale_libc.c.

{
    return iswalnum_l((wint_t) wc, locale->lt);
}

References fb(), iswalnum_l, and pg_locale_struct::lt.

wc_isalnum_libc_sb()

static bool wc_isalnum_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 142 of file pg_locale_libc.c.

{
    return isalnum_l((unsigned char) wc, locale->lt);
}

References isalnum_l, and pg_locale_struct::lt.

wc_isalpha_libc_mb()

static bool wc_isalpha_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 207 of file pg_locale_libc.c.

{
    return iswalpha_l((wint_t) wc, locale->lt);
}

References fb(), iswalpha_l, and pg_locale_struct::lt.

wc_isalpha_libc_sb()

static bool wc_isalpha_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 136 of file pg_locale_libc.c.

{
    return isalpha_l((unsigned char) wc, locale->lt);
}

References isalpha_l, and pg_locale_struct::lt.

wc_iscased_libc_mb()

static bool wc_iscased_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 265 of file pg_locale_libc.c.

{
    return iswupper_l((wint_t) wc, locale->lt) ||
        iswlower_l((wint_t) wc, locale->lt);
}

References fb(), iswlower_l, iswupper_l, and pg_locale_struct::lt.

wc_iscased_libc_sb()

static bool wc_iscased_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 194 of file pg_locale_libc.c.

{
    return isupper_l((unsigned char) wc, locale->lt) ||
        islower_l((unsigned char) wc, locale->lt);
}

References islower_l, isupper_l, and pg_locale_struct::lt.

wc_isdigit_libc_mb()

static bool wc_isdigit_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 201 of file pg_locale_libc.c.

{
    return iswdigit_l((wint_t) wc, locale->lt);
}

References fb(), iswdigit_l, and pg_locale_struct::lt.

wc_isdigit_libc_sb()

static bool wc_isdigit_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 130 of file pg_locale_libc.c.

{
    return isdigit_l((unsigned char) wc, locale->lt);
}

References isdigit_l, and pg_locale_struct::lt.

wc_isgraph_libc_mb()

static bool wc_isgraph_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 231 of file pg_locale_libc.c.

{
    return iswgraph_l((wint_t) wc, locale->lt);
}

References fb(), iswgraph_l, and pg_locale_struct::lt.

wc_isgraph_libc_sb()

static bool wc_isgraph_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 160 of file pg_locale_libc.c.

{
    return isgraph_l((unsigned char) wc, locale->lt);
}

References isgraph_l, and pg_locale_struct::lt.

wc_islower_libc_mb()

static bool wc_islower_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 225 of file pg_locale_libc.c.

{
    return iswlower_l((wint_t) wc, locale->lt);
}

References fb(), iswlower_l, and pg_locale_struct::lt.

wc_islower_libc_sb()

static bool wc_islower_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 154 of file pg_locale_libc.c.

{
    return islower_l((unsigned char) wc, locale->lt);
}

References islower_l, and pg_locale_struct::lt.

wc_isprint_libc_mb()

static bool wc_isprint_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 237 of file pg_locale_libc.c.

{
    return iswprint_l((wint_t) wc, locale->lt);
}

References fb(), iswprint_l, and pg_locale_struct::lt.

wc_isprint_libc_sb()

static bool wc_isprint_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 166 of file pg_locale_libc.c.

{
    return isprint_l((unsigned char) wc, locale->lt);
}

References isprint_l, and pg_locale_struct::lt.

wc_ispunct_libc_mb()

static bool wc_ispunct_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 243 of file pg_locale_libc.c.

{
    return iswpunct_l((wint_t) wc, locale->lt);
}

References fb(), iswpunct_l, and pg_locale_struct::lt.

wc_ispunct_libc_sb()

static bool wc_ispunct_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 172 of file pg_locale_libc.c.

{
    return ispunct_l((unsigned char) wc, locale->lt);
}

References ispunct_l, and pg_locale_struct::lt.

wc_isspace_libc_mb()

static bool wc_isspace_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 249 of file pg_locale_libc.c.

{
    return iswspace_l((wint_t) wc, locale->lt);
}

References fb(), iswspace_l, and pg_locale_struct::lt.

wc_isspace_libc_sb()

static bool wc_isspace_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 178 of file pg_locale_libc.c.

{
    return isspace_l((unsigned char) wc, locale->lt);
}

References isspace_l, and pg_locale_struct::lt.

wc_isupper_libc_mb()

static bool wc_isupper_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 219 of file pg_locale_libc.c.

{
    return iswupper_l((wint_t) wc, locale->lt);
}

References fb(), iswupper_l, and pg_locale_struct::lt.

wc_isupper_libc_sb()

static bool wc_isupper_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 148 of file pg_locale_libc.c.

{
    return isupper_l((unsigned char) wc, locale->lt);
}

References isupper_l, and pg_locale_struct::lt.

wc_isxdigit_libc_mb()

static bool wc_isxdigit_libc_mb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 255 of file pg_locale_libc.c.

{
#ifndef WIN32
    return iswxdigit_l((wint_t) wc, locale->lt);
#else
    return _iswxdigit_l((wint_t) wc, locale->lt);
#endif
}

References fb(), and pg_locale_struct::lt.

wc_isxdigit_libc_sb()

static bool wc_isxdigit_libc_sb ( pg_wchar  wc, pg_locale_t  locale  )

static

Definition at line 184 of file pg_locale_libc.c.

{
#ifndef WIN32
    return isxdigit_l((unsigned char) wc, locale->lt);
#else
    return _isxdigit_l((unsigned char) wc, locale->lt);
#endif
}

References fb(), and pg_locale_struct::lt.

wchar2char()

size_t wchar2char	(	char *	to,
		const wchar_t *	from,
		size_t	tolen,
		locale_t	loc
	)

Definition at line 1204 of file pg_locale_libc.c.

{
    size_t      result;
 
    if (tolen == 0)
        return 0;
 
#ifdef WIN32
 
    /*
     * On Windows, the "Unicode" locales assume UTF16 not UTF8 encoding, and
     * for some reason mbstowcs and wcstombs won't do this for us, so we use
     * MultiByteToWideChar().
     */
    if (GetDatabaseEncoding() == PG_UTF8)
    {
        result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,
                                     NULL, NULL);
        /* A zero return is failure */
        if (result <= 0)
            result = -1;
        else
        {
            Assert(result <= tolen);
            /* Microsoft counts the zero terminator in the result */
            result--;
        }
    }
    else
#endif                          /* WIN32 */
    if (loc == (locale_t) 0)
    {
        /* Use wcstombs directly for the default locale */
        result = wcstombs(to, from, tolen);
    }
    else
    {
        /* Use wcstombs_l for nondefault locales */
        result = wcstombs_l(to, from, tolen, loc);
    }
 
    return result;
}

References Assert, fb(), GetDatabaseEncoding(), locale_t, PG_UTF8, result, and wcstombs_l().

Referenced by set_backtrace(), strlower_libc_mb(), strtitle_libc_mb(), and strupper_libc_mb().

wcstombs_l()

static size_t wcstombs_l ( char *  dest, const wchar_t *  src, size_t  n, locale_t  loc  )

static

Definition at line 1176 of file pg_locale_libc.c.

{
#ifdef WIN32
    return _wcstombs_l(dest, src, n, loc);
#else
    size_t      result;
    locale_t    save_locale = uselocale(loc);
 
    result = wcstombs(dest, src, n);
    uselocale(save_locale);
    return result;
#endif
}

References fb(), locale_t, and result.

Referenced by wchar2char().

Variable Documentation

collate_methods_libc

const struct collate_methods collate_methods_libc

static

Initial value:

= {
    .strncoll = strncoll_libc,
    .strcoll = strcoll_libc,
    .strnxfrm = strnxfrm_libc,
    .strxfrm = strxfrm_libc,
    .strnxfrm_prefix = NULL,
    .strxfrm_prefix = NULL,
 
    
 
 
 
    .strxfrm_is_safe = false,
 
}

Definition at line 427 of file pg_locale_libc.c.

                                                           {
    .strncoll = strncoll_libc,
    .strcoll = strcoll_libc,
    .strnxfrm = strnxfrm_libc,
    .strxfrm = strxfrm_libc,
    .strnxfrm_prefix = NULL,
    .strxfrm_prefix = NULL,
 
    /*
     * Unfortunately, it seems that strxfrm() for non-C collations is broken
     * on many common platforms; testing of multiple versions of glibc reveals
     * that, for many locales, strcoll() and strxfrm() do not return
     * consistent results. While no other libc other than Cygwin has so far
     * been shown to have a problem, we take the conservative course of action
     * for right now and disable this categorically.  (Users who are certain
     * this isn't a problem on their system can define TRUST_STRXFRM.)
     */
#ifdef TRUST_STRXFRM
    .strxfrm_is_safe = true,
#else
    .strxfrm_is_safe = false,
#endif
};

Referenced by create_pg_locale_libc().

ctype_methods_libc_other_mb

const struct ctype_methods ctype_methods_libc_other_mb

static

Initial value:

= {
    .strlower = strlower_libc_mb,
    .strtitle = strtitle_libc_mb,
    .strupper = strupper_libc_mb,
    
    .strfold = strlower_libc_mb,
    
    .downcase_ident = NULL,
    .wc_isdigit = wc_isdigit_libc_sb,
    .wc_isalpha = wc_isalpha_libc_sb,
    .wc_isalnum = wc_isalnum_libc_sb,
    .wc_isupper = wc_isupper_libc_sb,
    .wc_islower = wc_islower_libc_sb,
    .wc_isgraph = wc_isgraph_libc_sb,
    .wc_isprint = wc_isprint_libc_sb,
    .wc_ispunct = wc_ispunct_libc_sb,
    .wc_isspace = wc_isspace_libc_sb,
    .wc_isxdigit = wc_isxdigit_libc_sb,
    .wc_iscased = wc_iscased_libc_sb,
    .wc_toupper = toupper_libc_sb,
    .wc_tolower = tolower_libc_sb,
}

Definition at line 381 of file pg_locale_libc.c.

                                                                {
    .strlower = strlower_libc_mb,
    .strtitle = strtitle_libc_mb,
    .strupper = strupper_libc_mb,
    /* in libc, casefolding is the same as lowercasing */
    .strfold = strlower_libc_mb,
    /* uses plain ASCII semantics for historical reasons */
    .downcase_ident = NULL,
    .wc_isdigit = wc_isdigit_libc_sb,
    .wc_isalpha = wc_isalpha_libc_sb,
    .wc_isalnum = wc_isalnum_libc_sb,
    .wc_isupper = wc_isupper_libc_sb,
    .wc_islower = wc_islower_libc_sb,
    .wc_isgraph = wc_isgraph_libc_sb,
    .wc_isprint = wc_isprint_libc_sb,
    .wc_ispunct = wc_ispunct_libc_sb,
    .wc_isspace = wc_isspace_libc_sb,
    .wc_isxdigit = wc_isxdigit_libc_sb,
    .wc_iscased = wc_iscased_libc_sb,
    .wc_toupper = toupper_libc_sb,
    .wc_tolower = tolower_libc_sb,
};

Referenced by create_pg_locale_libc().

ctype_methods_libc_sb

const struct ctype_methods ctype_methods_libc_sb

static

Initial value:

= {
    .strlower = strlower_libc_sb,
    .strtitle = strtitle_libc_sb,
    .strupper = strupper_libc_sb,
    
    .strfold = strlower_libc_sb,
    .downcase_ident = downcase_ident_libc_sb,
    .wc_isdigit = wc_isdigit_libc_sb,
    .wc_isalpha = wc_isalpha_libc_sb,
    .wc_isalnum = wc_isalnum_libc_sb,
    .wc_isupper = wc_isupper_libc_sb,
    .wc_islower = wc_islower_libc_sb,
    .wc_isgraph = wc_isgraph_libc_sb,
    .wc_isprint = wc_isprint_libc_sb,
    .wc_ispunct = wc_ispunct_libc_sb,
    .wc_isspace = wc_isspace_libc_sb,
    .wc_isxdigit = wc_isxdigit_libc_sb,
    .wc_iscased = wc_iscased_libc_sb,
    .wc_toupper = toupper_libc_sb,
    .wc_tolower = tolower_libc_sb,
}

Definition at line 355 of file pg_locale_libc.c.

                                                          {
    .strlower = strlower_libc_sb,
    .strtitle = strtitle_libc_sb,
    .strupper = strupper_libc_sb,
    /* in libc, casefolding is the same as lowercasing */
    .strfold = strlower_libc_sb,
    .downcase_ident = downcase_ident_libc_sb,
    .wc_isdigit = wc_isdigit_libc_sb,
    .wc_isalpha = wc_isalpha_libc_sb,
    .wc_isalnum = wc_isalnum_libc_sb,
    .wc_isupper = wc_isupper_libc_sb,
    .wc_islower = wc_islower_libc_sb,
    .wc_isgraph = wc_isgraph_libc_sb,
    .wc_isprint = wc_isprint_libc_sb,
    .wc_ispunct = wc_ispunct_libc_sb,
    .wc_isspace = wc_isspace_libc_sb,
    .wc_isxdigit = wc_isxdigit_libc_sb,
    .wc_iscased = wc_iscased_libc_sb,
    .wc_toupper = toupper_libc_sb,
    .wc_tolower = tolower_libc_sb,
};

Referenced by create_pg_locale_libc().

ctype_methods_libc_utf8

const struct ctype_methods ctype_methods_libc_utf8

static

Initial value:

= {
    .strlower = strlower_libc_mb,
    .strtitle = strtitle_libc_mb,
    .strupper = strupper_libc_mb,
    
    .strfold = strlower_libc_mb,
    
    .downcase_ident = NULL,
    .wc_isdigit = wc_isdigit_libc_mb,
    .wc_isalpha = wc_isalpha_libc_mb,
    .wc_isalnum = wc_isalnum_libc_mb,
    .wc_isupper = wc_isupper_libc_mb,
    .wc_islower = wc_islower_libc_mb,
    .wc_isgraph = wc_isgraph_libc_mb,
    .wc_isprint = wc_isprint_libc_mb,
    .wc_ispunct = wc_ispunct_libc_mb,
    .wc_isspace = wc_isspace_libc_mb,
    .wc_isxdigit = wc_isxdigit_libc_mb,
    .wc_iscased = wc_iscased_libc_mb,
    .wc_toupper = toupper_libc_mb,
    .wc_tolower = tolower_libc_mb,
}

Definition at line 404 of file pg_locale_libc.c.

                                                            {
    .strlower = strlower_libc_mb,
    .strtitle = strtitle_libc_mb,
    .strupper = strupper_libc_mb,
    /* in libc, casefolding is the same as lowercasing */
    .strfold = strlower_libc_mb,
    /* uses plain ASCII semantics for historical reasons */
    .downcase_ident = NULL,
    .wc_isdigit = wc_isdigit_libc_mb,
    .wc_isalpha = wc_isalpha_libc_mb,
    .wc_isalnum = wc_isalnum_libc_mb,
    .wc_isupper = wc_isupper_libc_mb,
    .wc_islower = wc_islower_libc_mb,
    .wc_isgraph = wc_isgraph_libc_mb,
    .wc_isprint = wc_isprint_libc_mb,
    .wc_ispunct = wc_ispunct_libc_mb,
    .wc_isspace = wc_isspace_libc_mb,
    .wc_isxdigit = wc_isxdigit_libc_mb,
    .wc_iscased = wc_iscased_libc_mb,
    .wc_toupper = toupper_libc_mb,
    .wc_tolower = tolower_libc_mb,
};

Referenced by create_pg_locale_libc().