#include "utils/guc.h"

Include dependency graph for pg_locale.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	pg_locale_struct

Typedefs
typedef struct pg_locale_struct *	pg_locale_t

Functions
bool	check_locale_messages (char newval, void extra, GucSource source)

void	assign_locale_messages (const char newval, void extra)

bool	check_locale_monetary (char newval, void extra, GucSource source)

void	assign_locale_monetary (const char newval, void extra)

bool	check_locale_numeric (char newval, void extra, GucSource source)

void	assign_locale_numeric (const char newval, void extra)

bool	check_locale_time (char newval, void extra, GucSource source)

void	assign_locale_time (const char newval, void extra)

bool	check_locale (int category, const char locale, char *canonname)

char *	pg_perm_setlocale (int category, const char *locale)

void	check_strxfrm_bug (void)

bool	lc_collate_is_c (Oid collation)

bool	lc_ctype_is_c (Oid collation)

struct lconv *	PGLC_localeconv (void)

void	cache_locale_time (void)

pg_locale_t	pg_newlocale_from_collation (Oid collid)

char *	get_collation_actual_version (char collprovider, const char *collcollate)

size_t	wchar2char (char to, const wchar_t from, size_t tolen, pg_locale_t locale)

size_t	char2wchar (wchar_t to, size_t tolen, const char from, size_t fromlen, pg_locale_t locale)

Variables
char *	locale_messages

char *	locale_monetary

char *	locale_numeric

char *	locale_time

char *	localized_abbrev_days []

char *	localized_full_days []

char *	localized_abbrev_months []

char *	localized_full_months []

Typedef Documentation

typedef struct pg_locale_struct* pg_locale_t

Definition at line 101 of file pg_locale.h.

Function Documentation

void assign_locale_messages	(	const char *	newval,
		void *	extra
	)

Definition at line 376 of file pg_locale.c.

References pg_perm_setlocale().

 {
     /*
      * LC_MESSAGES category does not exist everywhere, but accept it anyway.
      * We ignore failure, as per comment above.
      */
 #ifdef LC_MESSAGES
     (void) pg_perm_setlocale(LC_MESSAGES, newval);
 #endif
 }

void assign_locale_monetary	(	const char *	newval,
		void *	extra
	)

Definition at line 313 of file pg_locale.c.

References CurrentLocaleConvValid.

 {
     CurrentLocaleConvValid = false;
 }

void assign_locale_numeric	(	const char *	newval,
		void *	extra
	)

Definition at line 325 of file pg_locale.c.

References CurrentLocaleConvValid.

 {
     CurrentLocaleConvValid = false;
 }

void assign_locale_time	(	const char *	newval,
		void *	extra
	)

Definition at line 337 of file pg_locale.c.

References CurrentLCTimeValid.

 {
     CurrentLCTimeValid = false;
 }

void cache_locale_time ( void )

Definition at line 786 of file pg_locale.c.

References cache_single_time(), CurrentLCTimeValid, DEBUG3, elog, i, locale_time, localized_abbrev_days, localized_abbrev_months, localized_full_days, localized_full_months, pfree(), pstrdup(), timenow(), and WARNING.

Referenced by DCH_to_char().

 {
     char       *save_lc_time;
     time_t      timenow;
     struct tm  *timeinfo;
     int         i;
 
 #ifdef WIN32
     char       *save_lc_ctype;
 #endif
 
     /* did we do this already? */
     if (CurrentLCTimeValid)
         return;
 
     elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
 
     /* save user's value of time locale */
     save_lc_time = setlocale(LC_TIME, NULL);
     if (save_lc_time)
         save_lc_time = pstrdup(save_lc_time);
 
 #ifdef WIN32
 
     /*
      * On WIN32, there is no way to get locale-specific time values in a
      * specified locale, like we do for monetary/numeric.  We can only get
      * CP_ACP (see strftime_win32) or UTF16.  Therefore, we get UTF16 and
      * convert it to the database locale.  However, wcsftime() internally uses
      * LC_CTYPE, so we set it here.  See the WIN32 comment near the top of
      * PGLC_localeconv().
      */
 
     /* save user's value of ctype locale */
     save_lc_ctype = setlocale(LC_CTYPE, NULL);
     if (save_lc_ctype)
         save_lc_ctype = pstrdup(save_lc_ctype);
 
     /* use lc_time to set the ctype */
     setlocale(LC_CTYPE, locale_time);
 #endif
 
     setlocale(LC_TIME, locale_time);
 
     timenow = time(NULL);
     timeinfo = localtime(&timenow);
 
     /* localized days */
     for (i = 0; i < 7; i++)
     {
         timeinfo->tm_wday = i;
         cache_single_time(&localized_abbrev_days[i], "%a", timeinfo);
         cache_single_time(&localized_full_days[i], "%A", timeinfo);
     }
 
     /* localized months */
     for (i = 0; i < 12; i++)
     {
         timeinfo->tm_mon = i;
         timeinfo->tm_mday = 1;  /* make sure we don't have invalid date */
         cache_single_time(&localized_abbrev_months[i], "%b", timeinfo);
         cache_single_time(&localized_full_months[i], "%B", timeinfo);
     }
 
     /* try to restore internal settings */
     if (save_lc_time)
     {
         if (!setlocale(LC_TIME, save_lc_time))
             elog(WARNING, "failed to restore old locale");
         pfree(save_lc_time);
     }
 
 #ifdef WIN32
     /* try to restore internal ctype settings */
     if (save_lc_ctype)
     {
         if (!setlocale(LC_CTYPE, save_lc_ctype))
             elog(WARNING, "failed to restore old locale");
         pfree(save_lc_ctype);
     }
 #endif
 
     CurrentLCTimeValid = true;
 }

size_t char2wchar	(	wchar_t *	to,
		size_t	tolen,
		const char *	from,
		size_t	fromlen,
		pg_locale_t	locale
	)

Definition at line 1677 of file pg_locale.c.

References Assert, COLLPROVIDER_LIBC, elog, ereport, errcode(), errhint(), errmsg(), ERROR, GetDatabaseEncoding(), pg_locale_struct::info, locale_t, mbstowcs_l, pfree(), PG_UTF8, pg_verifymbstr(), pnstrdup(), and pg_locale_struct::provider.

Referenced by lowerstr_with_len(), str_initcap(), str_tolower(), str_toupper(), t_isalpha(), t_isdigit(), t_isprint(), t_isspace(), and TParserInit().

 {
     size_t      result;
 
     Assert(!locale || locale->provider == COLLPROVIDER_LIBC);
 
     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 (locale == (pg_locale_t) 0)
         {
             /* Use mbstowcs directly for the default locale */
             result = mbstowcs(to, str, tolen);
         }
         else
         {
 #ifdef HAVE_LOCALE_T
 #ifdef HAVE_MBSTOWCS_L
             /* Use mbstowcs_l for nondefault locales */
             result = mbstowcs_l(to, str, tolen, locale->info.lt);
 #else                           /* !HAVE_MBSTOWCS_L */
             /* We have to temporarily set the locale as current ... ugh */
             locale_t    save_locale = uselocale(locale->info.lt);
 
             result = mbstowcs(to, str, tolen);
 
             uselocale(save_locale);
 #endif                          /* HAVE_MBSTOWCS_L */
 #else                           /* !HAVE_LOCALE_T */
             /* Can't have locale != 0 without HAVE_LOCALE_T */
             elog(ERROR, "mbstowcs_l is not available");
             result = 0;         /* keep compiler quiet */
 #endif                          /* HAVE_LOCALE_T */
         }
 
         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 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;
 }

bool check_locale	(	int	category,
		const char *	locale,
		char **	canonname
	)

Definition at line 264 of file pg_locale.c.

References elog, pfree(), pstrdup(), and WARNING.

Referenced by check_locale_messages(), check_locale_monetary(), check_locale_numeric(), check_locale_time(), and createdb().

 {
     char       *save;
     char       *res;
 
     if (canonname)
         *canonname = NULL;      /* in case of failure */
 
     save = setlocale(category, NULL);
     if (!save)
         return false;           /* won't happen, we hope */
 
     /* save may be pointing at a modifiable scratch variable, see above. */
     save = pstrdup(save);
 
     /* set the locale with setlocale, to see if it accepts it. */
     res = setlocale(category, locale);
 
     /* save canonical name if requested. */
     if (res && canonname)
         *canonname = pstrdup(res);
 
     /* restore old value. */
     if (!setlocale(category, save))
         elog(WARNING, "failed to restore old locale \"%s\"", save);
     pfree(save);
 
     return (res != NULL);
 }

bool check_locale_messages	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 353 of file pg_locale.c.

References check_locale(), and PGC_S_DEFAULT.

 {
     if (**newval == '\0')
     {
         if (source == PGC_S_DEFAULT)
             return true;
         else
             return false;
     }
 
     /*
      * LC_MESSAGES category does not exist everywhere, but accept it anyway
      *
      * On Windows, we can't even check the value, so accept blindly
      */
 #if defined(LC_MESSAGES) && !defined(WIN32)
     return check_locale(LC_MESSAGES, *newval, NULL);
 #else
     return true;
 #endif
 }

bool check_locale_monetary	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 307 of file pg_locale.c.

References check_locale().

 {
     return check_locale(LC_MONETARY, *newval, NULL);
 }

bool check_locale_numeric	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 319 of file pg_locale.c.

References check_locale().

 {
     return check_locale(LC_NUMERIC, *newval, NULL);
 }

bool check_locale_time	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 331 of file pg_locale.c.

References check_locale().

 {
     return check_locale(LC_TIME, *newval, NULL);
 }

void check_strxfrm_bug ( void )

Definition at line 993 of file pg_locale.c.

References buf, ereport, errcode(), errhint(), errmsg_internal(), and ERROR.

Referenced by CheckMyDatabase(), and main().

 {
     char        buf[32];
     const int   canary = 0x7F;
     bool        ok = true;
 
     /*
      * Given a two-byte ASCII string and length limit 7, 8 or 9, Solaris 10
      * 05/08 returns 18 and modifies 10 bytes.  It respects limits above or
      * below that range.
      *
      * The bug is present in Solaris 8 as well; it is absent in Solaris 10
      * 01/13 and Solaris 11.2.  Affected locales include is_IS.ISO8859-1,
      * en_US.UTF-8, en_US.ISO8859-1, and ru_RU.KOI8-R.  Unaffected locales
      * include de_DE.UTF-8, de_DE.ISO8859-1, zh_TW.UTF-8, and C.
      */
     buf[7] = canary;
     (void) strxfrm(buf, "ab", 7);
     if (buf[7] != canary)
         ok = false;
 
     /*
      * illumos bug #1594 was present in the source tree from 2010-10-11 to
      * 2012-02-01.  Given an ASCII string of any length and length limit 1,
      * affected systems ignore the length limit and modify a number of bytes
      * one less than the return value.  The problem inputs for this bug do not
      * overlap those for the Solaris bug, hence a distinct test.
      *
      * Affected systems include smartos-20110926T021612Z.  Affected locales
      * include en_US.ISO8859-1 and en_US.UTF-8.  Unaffected locales include C.
      */
     buf[1] = canary;
     (void) strxfrm(buf, "a", 1);
     if (buf[1] != canary)
         ok = false;
 
     if (!ok)
         ereport(ERROR,
                 (errcode(ERRCODE_SYSTEM_ERROR),
                  errmsg_internal("strxfrm(), in locale \"%s\", writes past the specified array length",
                                  setlocale(LC_COLLATE, NULL)),
                  errhint("Apply system library package updates.")));
 }

char* get_collation_actual_version	(	char	collprovider,
		const char *	collcollate
	)

Definition at line 1452 of file pg_locale.c.

References buf, COLLPROVIDER_ICU, ereport, errmsg(), ERROR, pstrdup(), and status().

Referenced by AlterCollation(), DefineCollation(), pg_collation_actual_version(), pg_import_system_collations(), and pg_newlocale_from_collation().

 {
     char       *collversion;
 
 #ifdef USE_ICU
     if (collprovider == COLLPROVIDER_ICU)
     {
         UCollator  *collator;
         UErrorCode  status;
         UVersionInfo versioninfo;
         char        buf[U_MAX_VERSION_STRING_LENGTH];
 
         status = U_ZERO_ERROR;
         collator = ucol_open(collcollate, &status);
         if (U_FAILURE(status))
             ereport(ERROR,
                     (errmsg("could not open collator for locale \"%s\": %s",
                             collcollate, u_errorName(status))));
         ucol_getVersion(collator, versioninfo);
         ucol_close(collator);
 
         u_versionToString(versioninfo, buf);
         collversion = pstrdup(buf);
     }
     else
 #endif
         collversion = NULL;
 
     return collversion;
 }

bool lc_collate_is_c ( Oid collation )

Definition at line 1128 of file pg_locale.c.

References C_COLLATION_OID, DEFAULT_COLLATION_OID, elog, ERROR, lookup_collation_cache(), OidIsValid, and POSIX_COLLATION_OID.

Referenced by convert_string_datum(), DefineCollation(), make_greater_string(), match_special_index_operator(), spg_text_inner_consistent(), varstr_cmp(), and varstr_sortsupport().

 {
     /*
      * If we're asked about "collation 0", return false, so that the code will
      * go into the non-C path and report that the collation is bogus.
      */
     if (!OidIsValid(collation))
         return false;
 
     /*
      * If we're asked about the default collation, we have to inquire of the C
      * library.  Cache the result so we only have to compute it once.
      */
     if (collation == DEFAULT_COLLATION_OID)
     {
         static int  result = -1;
         char       *localeptr;
 
         if (result >= 0)
             return (bool) result;
         localeptr = setlocale(LC_COLLATE, NULL);
         if (!localeptr)
             elog(ERROR, "invalid LC_COLLATE setting");
 
         if (strcmp(localeptr, "C") == 0)
             result = true;
         else if (strcmp(localeptr, "POSIX") == 0)
             result = true;
         else
             result = false;
         return (bool) result;
     }
 
     /*
      * If we're asked about the built-in C/POSIX collations, we know that.
      */
     if (collation == C_COLLATION_OID ||
         collation == POSIX_COLLATION_OID)
         return true;
 
     /*
      * Otherwise, we have to consult pg_collation, but we cache that.
      */
     return (lookup_collation_cache(collation, true))->collate_is_c;
 }

bool lc_ctype_is_c ( Oid collation )

Definition at line 1178 of file pg_locale.c.

References C_COLLATION_OID, DEFAULT_COLLATION_OID, elog, ERROR, lookup_collation_cache(), OidIsValid, and POSIX_COLLATION_OID.

Referenced by DefineCollation(), Generic_Text_IC_like(), like_fixed_prefix(), lowerstr_with_len(), pg_set_regex_collation(), str_initcap(), str_tolower(), str_toupper(), t_isalpha(), t_isdigit(), t_isprint(), t_isspace(), and TParserInit().

 {
     /*
      * If we're asked about "collation 0", return false, so that the code will
      * go into the non-C path and report that the collation is bogus.
      */
     if (!OidIsValid(collation))
         return false;
 
     /*
      * If we're asked about the default collation, we have to inquire of the C
      * library.  Cache the result so we only have to compute it once.
      */
     if (collation == DEFAULT_COLLATION_OID)
     {
         static int  result = -1;
         char       *localeptr;
 
         if (result >= 0)
             return (bool) result;
         localeptr = setlocale(LC_CTYPE, NULL);
         if (!localeptr)
             elog(ERROR, "invalid LC_CTYPE setting");
 
         if (strcmp(localeptr, "C") == 0)
             result = true;
         else if (strcmp(localeptr, "POSIX") == 0)
             result = true;
         else
             result = false;
         return (bool) result;
     }
 
     /*
      * If we're asked about the built-in C/POSIX collations, we know that.
      */
     if (collation == C_COLLATION_OID ||
         collation == POSIX_COLLATION_OID)
         return true;
 
     /*
      * Otherwise, we have to consult pg_collation, but we cache that.
      */
     return (lookup_collation_cache(collation, true))->ctype_is_c;
 }

pg_locale_t pg_newlocale_from_collation ( Oid collid )

Definition at line 1275 of file pg_locale.c.

References Anum_pg_collation_collversion, Assert, COLLOID, COLLPROVIDER_ICU, COLLPROVIDER_LIBC, DEFAULT_COLLATION_OID, elog, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, get_collation_actual_version(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, pg_locale_struct::info, collation_cache_entry::locale, locale_t, lookup_collation_cache(), MemoryContextAlloc(), MemoryContextStrdup(), NameStr, ObjectIdGetDatum, OidIsValid, pg_attribute_unused, pg_locale_struct::provider, quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), status(), SysCacheGetAttr(), TextDatumGetCString, TopMemoryContext, and WARNING.

Referenced by DefineCollation(), Generic_Text_IC_like(), like_fixed_prefix(), pg_set_regex_collation(), str_initcap(), str_tolower(), str_toupper(), varstr_cmp(), and varstr_sortsupport().

 {
     collation_cache_entry *cache_entry;
 
     /* Callers must pass a valid OID */
     Assert(OidIsValid(collid));
 
     /* Return 0 for "default" collation, just in case caller forgets */
     if (collid == DEFAULT_COLLATION_OID)
         return (pg_locale_t) 0;
 
     cache_entry = lookup_collation_cache(collid, false);
 
     if (cache_entry->locale == 0)
     {
         /* We haven't computed this yet in this session, so do it */
         HeapTuple   tp;
         Form_pg_collation collform;
         const char *collcollate;
         const char *collctype pg_attribute_unused();
         struct pg_locale_struct result;
         pg_locale_t resultp;
         Datum       collversion;
         bool        isnull;
 
         tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
         if (!HeapTupleIsValid(tp))
             elog(ERROR, "cache lookup failed for collation %u", collid);
         collform = (Form_pg_collation) GETSTRUCT(tp);
 
         collcollate = NameStr(collform->collcollate);
         collctype = NameStr(collform->collctype);
 
         /* We'll fill in the result struct locally before allocating memory */
         memset(&result, 0, sizeof(result));
         result.provider = collform->collprovider;
 
         if (collform->collprovider == COLLPROVIDER_LIBC)
         {
 #ifdef HAVE_LOCALE_T
             locale_t    loc;
 
             if (strcmp(collcollate, collctype) == 0)
             {
                 /* Normal case where they're the same */
                 errno = 0;
 #ifndef WIN32
                 loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,
                                 NULL);
 #else
                 loc = _create_locale(LC_ALL, collcollate);
 #endif
                 if (!loc)
                     report_newlocale_failure(collcollate);
             }
             else
             {
 #ifndef WIN32
                 /* We need two newlocale() steps */
                 locale_t    loc1;
 
                 errno = 0;
                 loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);
                 if (!loc1)
                     report_newlocale_failure(collcollate);
                 errno = 0;
                 loc = newlocale(LC_CTYPE_MASK, collctype, loc1);
                 if (!loc)
                     report_newlocale_failure(collctype);
 #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
             }
 
             result.info.lt = loc;
 #else                           /* not HAVE_LOCALE_T */
             /* platform that doesn't support locale_t */
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("collation provider LIBC is not supported on this platform")));
 #endif                          /* not HAVE_LOCALE_T */
         }
         else if (collform->collprovider == COLLPROVIDER_ICU)
         {
 #ifdef USE_ICU
             UCollator  *collator;
             UErrorCode  status;
 
             if (strcmp(collcollate, collctype) != 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("collations with different collate and ctype values are not supported by ICU")));
 
             status = U_ZERO_ERROR;
             collator = ucol_open(collcollate, &status);
             if (U_FAILURE(status))
                 ereport(ERROR,
                         (errmsg("could not open collator for locale \"%s\": %s",
                                 collcollate, u_errorName(status))));
 
             /* We will leak this string if we get an error below :-( */
             result.info.icu.locale = MemoryContextStrdup(TopMemoryContext,
                                                          collcollate);
             result.info.icu.ucol = collator;
 #else                           /* not USE_ICU */
             /* could get here if a collation was created by a build with ICU */
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("ICU is not supported in this build"), \
                      errhint("You need to rebuild PostgreSQL using --with-icu.")));
 #endif                          /* not USE_ICU */
         }
 
         collversion = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collversion,
                                       &isnull);
         if (!isnull)
         {
             char       *actual_versionstr;
             char       *collversionstr;
 
             actual_versionstr = get_collation_actual_version(collform->collprovider, collcollate);
             if (!actual_versionstr)
             {
                 /*
                  * This could happen when specifying a version in CREATE
                  * COLLATION for a libc locale, or manually creating a mess in
                  * the catalogs.
                  */
                 ereport(ERROR,
                         (errmsg("collation \"%s\" has no actual version, but a version was specified",
                                 NameStr(collform->collname))));
             }
             collversionstr = TextDatumGetCString(collversion);
 
             if (strcmp(actual_versionstr, collversionstr) != 0)
                 ereport(WARNING,
                         (errmsg("collation \"%s\" has version mismatch",
                                 NameStr(collform->collname)),
                          errdetail("The collation in the database was created using version %s, "
                                    "but the operating system provides version %s.",
                                    collversionstr, actual_versionstr),
                          errhint("Rebuild all objects affected by this collation and run "
                                  "ALTER COLLATION %s REFRESH VERSION, "
                                  "or build PostgreSQL with the right library version.",
                                  quote_qualified_identifier(get_namespace_name(collform->collnamespace),
                                                             NameStr(collform->collname)))));
         }
 
         ReleaseSysCache(tp);
 
         /* We'll keep the pg_locale_t structures in TopMemoryContext */
         resultp = MemoryContextAlloc(TopMemoryContext, sizeof(*resultp));
         *resultp = result;
 
         cache_entry->locale = resultp;
     }
 
     return cache_entry->locale;
 }

char* pg_perm_setlocale	(	int	category,
		const char *	locale
	)

Definition at line 151 of file pg_locale.c.

References elog, FATAL, GetDatabaseEncoding(), lc_collate_envbuf, lc_ctype_envbuf, LC_ENV_BUFSIZE, lc_monetary_envbuf, lc_numeric_envbuf, lc_time_envbuf, putenv, SetMessageEncoding(), snprintf(), and strlcpy().

Referenced by assign_locale_messages(), CheckMyDatabase(), and init_locale().

 {
     char       *result;
     const char *envvar;
     char       *envbuf;
 
 #ifndef WIN32
     result = setlocale(category, locale);
 #else
 
     /*
      * On Windows, setlocale(LC_MESSAGES) does not work, so just assume that
      * the given value is good and set it in the environment variables. We
      * must ignore attempts to set to "", which means "keep using the old
      * environment value".
      */
 #ifdef LC_MESSAGES
     if (category == LC_MESSAGES)
     {
         result = (char *) locale;
         if (locale == NULL || locale[0] == '\0')
             return result;
     }
     else
 #endif
         result = setlocale(category, locale);
 #endif                          /* WIN32 */
 
     if (result == NULL)
         return result;          /* fall out immediately on failure */
 
     /*
      * Use the right encoding in translated messages.  Under ENABLE_NLS, let
      * pg_bind_textdomain_codeset() figure it out.  Under !ENABLE_NLS, message
      * format strings are ASCII, but database-encoding strings may enter the
      * message via %s.  This makes the overall message encoding equal to the
      * database encoding.
      */
     if (category == LC_CTYPE)
     {
         static char save_lc_ctype[LC_ENV_BUFSIZE];
 
         /* copy setlocale() return value before callee invokes it again */
         strlcpy(save_lc_ctype, result, sizeof(save_lc_ctype));
         result = save_lc_ctype;
 
 #ifdef ENABLE_NLS
         SetMessageEncoding(pg_bind_textdomain_codeset(textdomain(NULL)));
 #else
         SetMessageEncoding(GetDatabaseEncoding());
 #endif
     }
 
     switch (category)
     {
         case LC_COLLATE:
             envvar = "LC_COLLATE";
             envbuf = lc_collate_envbuf;
             break;
         case LC_CTYPE:
             envvar = "LC_CTYPE";
             envbuf = lc_ctype_envbuf;
             break;
 #ifdef LC_MESSAGES
         case LC_MESSAGES:
             envvar = "LC_MESSAGES";
             envbuf = lc_messages_envbuf;
 #ifdef WIN32
             result = IsoLocaleName(locale);
             if (result == NULL)
                 result = (char *) locale;
 #endif                          /* WIN32 */
             break;
 #endif                          /* LC_MESSAGES */
         case LC_MONETARY:
             envvar = "LC_MONETARY";
             envbuf = lc_monetary_envbuf;
             break;
         case LC_NUMERIC:
             envvar = "LC_NUMERIC";
             envbuf = lc_numeric_envbuf;
             break;
         case LC_TIME:
             envvar = "LC_TIME";
             envbuf = lc_time_envbuf;
             break;
         default:
             elog(FATAL, "unrecognized LC category: %d", category);
             envvar = NULL;      /* keep compiler quiet */
             envbuf = NULL;
             return NULL;
     }
 
     snprintf(envbuf, LC_ENV_BUFSIZE - 1, "%s=%s", envvar, result);
 
     if (putenv(envbuf))
         return NULL;
 
     return result;
 }

struct lconv* PGLC_localeconv ( void )

Definition at line 483 of file pg_locale.c.

References CurrentLocaleConvValid, db_encoding_convert(), elog, encoding, ereport, errcode(), errmsg(), ERROR, free_struct_lconv(), locale_monetary, locale_numeric, pfree(), PG_CATCH, PG_END_TRY, pg_get_encoding_from_locale(), PG_RE_THROW, PG_TRY, pstrdup(), struct_lconv_is_valid(), and WARNING.

Referenced by cash_in(), cash_numeric(), cash_out(), int4_cash(), int8_cash(), NUM_prepare_locale(), and numeric_cash().

 {
     static struct lconv CurrentLocaleConv;
     static bool CurrentLocaleConvAllocated = false;
     struct lconv *extlconv;
     struct lconv worklconv;
     bool        trouble = false;
     char       *save_lc_monetary;
     char       *save_lc_numeric;
 #ifdef WIN32
     char       *save_lc_ctype;
 #endif
 
     /* Did we do it already? */
     if (CurrentLocaleConvValid)
         return &CurrentLocaleConv;
 
     /* Free any already-allocated storage */
     if (CurrentLocaleConvAllocated)
     {
         free_struct_lconv(&CurrentLocaleConv);
         CurrentLocaleConvAllocated = false;
     }
 
     /*
      * This is tricky because we really don't want to risk throwing error
      * while the locale is set to other than our usual settings.  Therefore,
      * the process is: collect the usual settings, set locale to special
      * setting, copy relevant data into worklconv using strdup(), restore
      * normal settings, convert data to desired encoding, and finally stash
      * the collected data in CurrentLocaleConv.  This makes it safe if we
      * throw an error during encoding conversion or run out of memory anywhere
      * in the process.  All data pointed to by struct lconv members is
      * allocated with strdup, to avoid premature elog(ERROR) and to allow
      * using a single cleanup routine.
      */
     memset(&worklconv, 0, sizeof(worklconv));
 
     /* Save user's values of monetary and numeric locales */
     save_lc_monetary = setlocale(LC_MONETARY, NULL);
     if (save_lc_monetary)
         save_lc_monetary = pstrdup(save_lc_monetary);
 
     save_lc_numeric = setlocale(LC_NUMERIC, NULL);
     if (save_lc_numeric)
         save_lc_numeric = pstrdup(save_lc_numeric);
 
 #ifdef WIN32
 
     /*
      * Ideally, monetary and numeric local symbols could be returned in any
      * server encoding.  Unfortunately, the WIN32 API does not allow
      * setlocale() to return values in a codepage/CTYPE that uses more than
      * two bytes per character, such as UTF-8:
      *
      * http://msdn.microsoft.com/en-us/library/x99tb11d.aspx
      *
      * Evidently, LC_CTYPE allows us to control the encoding used for strings
      * returned by localeconv().  The Open Group standard, mentioned at the
      * top of this C file, doesn't explicitly state this.
      *
      * Therefore, we set LC_CTYPE to match LC_NUMERIC or LC_MONETARY (which
      * cannot be UTF8), call localeconv(), and then convert from the
      * numeric/monetary LC_CTYPE to the server encoding.  One example use of
      * this is for the Euro symbol.
      *
      * Perhaps someday we will use GetLocaleInfoW() which returns values in
      * UTF16 and convert from that.
      */
 
     /* save user's value of ctype locale */
     save_lc_ctype = setlocale(LC_CTYPE, NULL);
     if (save_lc_ctype)
         save_lc_ctype = pstrdup(save_lc_ctype);
 
     /* Here begins the critical section where we must not throw error */
 
     /* use numeric to set the ctype */
     setlocale(LC_CTYPE, locale_numeric);
 #endif
 
     /* Get formatting information for numeric */
     setlocale(LC_NUMERIC, locale_numeric);
     extlconv = localeconv();
 
     /* Must copy data now in case setlocale() overwrites it */
     worklconv.decimal_point = strdup(extlconv->decimal_point);
     worklconv.thousands_sep = strdup(extlconv->thousands_sep);
     worklconv.grouping = strdup(extlconv->grouping);
 
 #ifdef WIN32
     /* use monetary to set the ctype */
     setlocale(LC_CTYPE, locale_monetary);
 #endif
 
     /* Get formatting information for monetary */
     setlocale(LC_MONETARY, locale_monetary);
     extlconv = localeconv();
 
     /* Must copy data now in case setlocale() overwrites it */
     worklconv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
     worklconv.currency_symbol = strdup(extlconv->currency_symbol);
     worklconv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
     worklconv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
     worklconv.mon_grouping = strdup(extlconv->mon_grouping);
     worklconv.positive_sign = strdup(extlconv->positive_sign);
     worklconv.negative_sign = strdup(extlconv->negative_sign);
     /* Copy scalar fields as well */
     worklconv.int_frac_digits = extlconv->int_frac_digits;
     worklconv.frac_digits = extlconv->frac_digits;
     worklconv.p_cs_precedes = extlconv->p_cs_precedes;
     worklconv.p_sep_by_space = extlconv->p_sep_by_space;
     worklconv.n_cs_precedes = extlconv->n_cs_precedes;
     worklconv.n_sep_by_space = extlconv->n_sep_by_space;
     worklconv.p_sign_posn = extlconv->p_sign_posn;
     worklconv.n_sign_posn = extlconv->n_sign_posn;
 
     /* Try to restore internal settings */
     if (save_lc_monetary)
     {
         if (!setlocale(LC_MONETARY, save_lc_monetary))
             trouble = true;
     }
 
     if (save_lc_numeric)
     {
         if (!setlocale(LC_NUMERIC, save_lc_numeric))
             trouble = true;
     }
 
 #ifdef WIN32
     /* Try to restore internal ctype settings */
     if (save_lc_ctype)
     {
         if (!setlocale(LC_CTYPE, save_lc_ctype))
             trouble = true;
     }
 #endif
 
     /*
      * At this point we've done our best to clean up, and can call functions
      * that might possibly throw errors with a clean conscience.  But let's
      * make sure we don't leak any already-strdup'd fields in worklconv.
      */
     PG_TRY();
     {
         int         encoding;
 
         /*
          * Report it if we failed to restore anything.  Perhaps this should be
          * FATAL, rather than continuing with bad locale settings?
          */
         if (trouble)
             elog(WARNING, "failed to restore old locale");
 
         /* Release the pstrdup'd locale names */
         if (save_lc_monetary)
             pfree(save_lc_monetary);
         if (save_lc_numeric)
             pfree(save_lc_numeric);
 #ifdef WIN32
         if (save_lc_ctype)
             pfree(save_lc_ctype);
 #endif
 
         /* If any of the preceding strdup calls failed, complain now. */
         if (!struct_lconv_is_valid(&worklconv))
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
 
         /*
          * Now we must perform encoding conversion from whatever's associated
          * with the locale into the database encoding.
          */
         encoding = pg_get_encoding_from_locale(locale_numeric, true);
 
         db_encoding_convert(encoding, &worklconv.decimal_point);
         db_encoding_convert(encoding, &worklconv.thousands_sep);
         /* grouping is not text and does not require conversion */
 
         encoding = pg_get_encoding_from_locale(locale_monetary, true);
 
         db_encoding_convert(encoding, &worklconv.int_curr_symbol);
         db_encoding_convert(encoding, &worklconv.currency_symbol);
         db_encoding_convert(encoding, &worklconv.mon_decimal_point);
         db_encoding_convert(encoding, &worklconv.mon_thousands_sep);
         /* mon_grouping is not text and does not require conversion */
         db_encoding_convert(encoding, &worklconv.positive_sign);
         db_encoding_convert(encoding, &worklconv.negative_sign);
     }
     PG_CATCH();
     {
         free_struct_lconv(&worklconv);
         PG_RE_THROW();
     }
     PG_END_TRY();
 
     /*
      * Everything is good, so save the results.
      */
     CurrentLocaleConv = worklconv;
     CurrentLocaleConvAllocated = true;
     CurrentLocaleConvValid = true;
     return &CurrentLocaleConv;
 }

size_t wchar2char	(	char *	to,
		const wchar_t *	from,
		size_t	tolen,
		pg_locale_t	locale
	)

Definition at line 1606 of file pg_locale.c.

References Assert, COLLPROVIDER_LIBC, elog, ERROR, GetDatabaseEncoding(), pg_locale_struct::info, locale_t, PG_UTF8, pg_locale_struct::provider, and wcstombs_l.

Referenced by lowerstr_with_len(), str_initcap(), str_tolower(), and str_toupper().

 {
     size_t      result;
 
     Assert(!locale || locale->provider == COLLPROVIDER_LIBC);
 
     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 (locale == (pg_locale_t) 0)
     {
         /* Use wcstombs directly for the default locale */
         result = wcstombs(to, from, tolen);
     }
     else
     {
 #ifdef HAVE_LOCALE_T
 #ifdef HAVE_WCSTOMBS_L
         /* Use wcstombs_l for nondefault locales */
         result = wcstombs_l(to, from, tolen, locale->info.lt);
 #else                           /* !HAVE_WCSTOMBS_L */
         /* We have to temporarily set the locale as current ... ugh */
         locale_t    save_locale = uselocale(locale->info.lt);
 
         result = wcstombs(to, from, tolen);
 
         uselocale(save_locale);
 #endif                          /* HAVE_WCSTOMBS_L */
 #else                           /* !HAVE_LOCALE_T */
         /* Can't have locale != 0 without HAVE_LOCALE_T */
         elog(ERROR, "wcstombs_l is not available");
         result = 0;             /* keep compiler quiet */
 #endif                          /* HAVE_LOCALE_T */
     }
 
     return result;
 }