PostgreSQL Source Code: src/include/utils/pg_locale.h File Reference (original) (raw)

Go to the source code of this file.

◆ LOCALE_NAME_BUFLEN

#define LOCALE_NAME_BUFLEN 128

◆ pg_locale_t

◆ builtin_locale_encoding()

Definition at line 1472 of file pg_locale.c.

1473{

1474 if (strcmp(locale, "C") == 0)

1475 return -1;

1476 else if (strcmp(locale, "C.UTF-8") == 0)

1478 else if (strcmp(locale, "PG_UNICODE_FAST") == 0)

1480

1481

1483 (errcode(ERRCODE_WRONG_OBJECT_TYPE),

1484 errmsg("invalid locale name \"%s\" for builtin provider",

1486

1487 return 0;

1488}

int errcode(int sqlerrcode)

int errmsg(const char *fmt,...)

#define ereport(elevel,...)

References ereport, errcode(), errmsg(), ERROR, locale, and PG_UTF8.

Referenced by builtin_validate_locale(), and DefineCollation().

◆ builtin_validate_locale()

Definition at line 1496 of file pg_locale.c.

1497{

1498 const char *canonical_name = NULL;

1499 int required_encoding;

1500

1501 if (strcmp(locale, "C") == 0)

1502 canonical_name = "C";

1503 else if (strcmp(locale, "C.UTF-8") == 0 || strcmp(locale, "C.UTF8") == 0)

1504 canonical_name = "C.UTF-8";

1505 else if (strcmp(locale, "PG_UNICODE_FAST") == 0)

1506 canonical_name = "PG_UNICODE_FAST";

1507

1508 if (!canonical_name)

1510 (errcode(ERRCODE_WRONG_OBJECT_TYPE),

1511 errmsg("invalid locale name \"%s\" for builtin provider",

1513

1515 if (required_encoding >= 0 && encoding != required_encoding)

1517 (errcode(ERRCODE_WRONG_OBJECT_TYPE),

1518 errmsg("encoding \"%s\" does not match locale \"%s\"",

1520

1521 return canonical_name;

1522}

int builtin_locale_encoding(const char *locale)

#define pg_encoding_to_char

References builtin_locale_encoding(), encoding, ereport, errcode(), errmsg(), ERROR, locale, and pg_encoding_to_char.

Referenced by create_pg_locale_builtin(), createdb(), and DefineCollation().

◆ cache_locale_time()

Definition at line 721 of file pg_locale.c.

722{

724 char *bufptr;

725 time_t timenow;

726 struct tm *timeinfo;

727 struct tm timeinfobuf;

728 bool strftimefail = false;

730 int i;

732

733

735 return;

736

738

739 errno = ENOENT;

740#ifdef WIN32

744#else

746#endif

749

750

751 timenow = time(NULL);

752 timeinfo = gmtime_r(&timenow, &timeinfobuf);

753

754

755 bufptr = buf;

756

757

758

759

760

761

762

763

764

765 errno = 0;

766

767

768 for (i = 0; i < 7; i++)

769 {

770 timeinfo->tm_wday = i;

772 strftimefail = true;

775 strftimefail = true;

777 }

778

779

780 for (i = 0; i < 12; i++)

781 {

782 timeinfo->tm_mon = i;

783 timeinfo->tm_mday = 1;

785 strftimefail = true;

788 strftimefail = true;

790 }

791

792#ifdef WIN32

793 _free_locale(locale);

794#else

796#endif

797

798

799

800

801

802 if (strftimefail)

803 elog(ERROR, "strftime_l() failed");

804

805#ifndef WIN32

806

807

808

809

810

811

815

816#else

817

818

819

820

821

823

824#endif

825

826 bufptr = buf;

827

828

829 for (i = 0; i < 7; i++)

830 {

835 }

838

839

840 for (i = 0; i < 12; i++)

841 {

846 }

849

851}

char * localized_full_months[12+1]

static bool CurrentLCTimeValid

static void cache_single_string(char **dst, const char *src, int encoding)

char * localized_abbrev_months[12+1]

char * localized_full_days[7+1]

char * localized_abbrev_days[7+1]

void report_newlocale_failure(const char *localename)

int pg_get_encoding_from_locale(const char *ctype, bool write_message)

void _dosmaperr(unsigned long)

References _dosmaperr(), buf, cache_single_string(), CurrentLCTimeValid, DEBUG3, elog, encoding, ERROR, i, locale, locale_t, locale_time, localized_abbrev_days, localized_abbrev_months, localized_full_days, localized_full_months, MAX_L10N_DATA, pg_get_encoding_from_locale(), PG_SQL_ASCII, PG_UTF8, report_newlocale_failure(), and tm.

Referenced by DCH_from_char(), and DCH_to_char().

◆ char2wchar()

Definition at line 936 of file pg_locale_libc.c.

938{

939 size_t result;

940

941 if (tolen == 0)

942 return 0;

943

944#ifdef WIN32

945

947 {

948

949 if (fromlen == 0)

950 result = 0;

951 else

952 {

953 result = MultiByteToWideChar(CP_UTF8, 0, from, fromlen, to, tolen - 1);

954

955 if (result == 0)

956 result = -1;

957 }

958

959 if (result != -1)

960 {

961 Assert(result < tolen);

962

963 to[result] = 0;

964 }

965 }

966 else

967#endif

968 {

969

971

973 {

974

975 result = mbstowcs(to, str, tolen);

976 }

977 else

978 {

979

981 }

982

984 }

985

986 if (result == -1)

987 {

988

989

990

991

992

993

994

995

996 pg_verifymbstr(from, fromlen, false);

997

999 (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),

1000 errmsg("invalid multibyte character for locale"),

1001 errhint("The server's LC_CTYPE locale is probably incompatible with the database encoding.")));

1002 }

1003

1004 return result;

1005}

int errhint(const char *fmt,...)

Assert(PointerIsAligned(start, uint64))

int GetDatabaseEncoding(void)

bool pg_verifymbstr(const char *mbstr, int len, bool noError)

void pfree(void *pointer)

char * pnstrdup(const char *in, Size len)

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

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

Referenced by strlower_libc_mb(), strtitle_libc_mb(), strupper_libc_mb(), t_isalnum(), t_isalpha(), and TParserInit().

◆ check_locale()

Definition at line 294 of file pg_locale.c.

295{

296 char *save;

297 char *res;

298

299

301 {

303 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

304 errmsg("locale name \"%s\" contains non-ASCII characters",

306 return false;

307 }

308

309 if (canonname)

310 *canonname = NULL;

311

312 save = setlocale(category, NULL);

313 if (!save)

314 return false;

315

316

318

319

321

322

323 if (res && canonname)

324 *canonname = pstrdup(res);

325

326

328 elog(WARNING, "failed to restore old locale \"%s\"", save);

330

331

332 if (canonname && *canonname && (*canonname))

333 {

335 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

336 errmsg("locale name \"%s\" contains non-ASCII characters",

337 *canonname)));

338 pfree(*canonname);

339 *canonname = NULL;

340 return false;

341 }

342

343 return (res != NULL);

344}

char * pstrdup(const char *in)

bool pg_is_ascii(const char *str)

References elog, ereport, errcode(), errmsg(), locale, pfree(), pg_is_ascii(), pstrdup(), setlocale, and WARNING.

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

◆ get_collation_actual_version()

◆ icu_language_tag()

Definition at line 1536 of file pg_locale.c.

1537{

1538#ifdef USE_ICU

1539 UErrorCode status;

1540 char *langtag;

1541 size_t buflen = 32;

1542 const bool strict = true;

1543

1544

1545

1546

1547

1548

1549

1550 langtag = palloc(buflen);

1551 while (true)

1552 {

1553 status = U_ZERO_ERROR;

1554 uloc_toLanguageTag(loc_str, langtag, buflen, strict, &status);

1555

1556

1557 if ((status == U_BUFFER_OVERFLOW_ERROR ||

1558 status == U_STRING_NOT_TERMINATED_WARNING) &&

1560 {

1562 langtag = repalloc(langtag, buflen);

1563 continue;

1564 }

1565

1566 break;

1567 }

1568

1569 if (U_FAILURE(status))

1570 {

1572

1573 if (elevel > 0)

1575 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

1576 errmsg("could not convert locale name \"%s\" to language tag: %s",

1577 loc_str, u_errorName(status))));

1578 return NULL;

1579 }

1580

1581 return langtag;

1582#else

1584 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

1585 errmsg("ICU is not supported in this build")));

1586 return NULL;

1587#endif

1588}

void * repalloc(void *pointer, Size size)

References ereport, errcode(), errmsg(), ERROR, MaxAllocSize, Min, palloc(), pfree(), and repalloc().

Referenced by createdb(), DefineCollation(), and pg_import_system_collations().

◆ icu_validate_locale()

Definition at line 1594 of file pg_locale.c.

1595{

1596#ifdef USE_ICU

1597 UCollator *collator;

1598 UErrorCode status;

1599 char lang[ULOC_LANG_CAPACITY];

1600 bool found = false;

1602

1603

1604 if (elevel < 0)

1605 return;

1606

1607

1610

1611

1612 status = U_ZERO_ERROR;

1613 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);

1614 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)

1615 {

1617 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

1618 errmsg("could not get language from ICU locale \"%s\": %s",

1619 loc_str, u_errorName(status)),

1620 errhint("To disable ICU locale validation, set the parameter \"%s\" to \"%s\".",

1621 "icu_validation_level", "disabled")));

1622 return;

1623 }

1624

1625

1626 if (strcmp(lang, "") == 0 ||

1627 strcmp(lang, "root") == 0 || strcmp(lang, "und") == 0)

1628 found = true;

1629

1630

1631 for (int32_t i = 0; !found && i < uloc_countAvailable(); i++)

1632 {

1633 const char *otherloc = uloc_getAvailable(i);

1634 char otherlang[ULOC_LANG_CAPACITY];

1635

1636 status = U_ZERO_ERROR;

1637 uloc_getLanguage(otherloc, otherlang, ULOC_LANG_CAPACITY, &status);

1638 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)

1639 continue;

1640

1641 if (strcmp(lang, otherlang) == 0)

1642 found = true;

1643 }

1644

1645 if (!found)

1647 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

1648 errmsg("ICU locale \"%s\" has unknown language \"%s\"",

1649 loc_str, lang),

1650 errhint("To disable ICU locale validation, set the parameter \"%s\" to \"%s\".",

1651 "icu_validation_level", "disabled")));

1652

1653

1654 collator = pg_ucol_open(loc_str);

1655 ucol_close(collator);

1656#else

1657

1659 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

1660 errmsg("ICU is not supported in this build")));

1661#endif

1662}

References ereport, errcode(), errhint(), errmsg(), ERROR, i, icu_validation_level, IsBinaryUpgrade, and WARNING.

Referenced by createdb(), and DefineCollation().

◆ init_database_collation()

Definition at line 1147 of file pg_locale.c.

1148{

1152

1154

1155

1160

1161 if (dbform->datlocprovider == COLLPROVIDER_BUILTIN)

1164 else if (dbform->datlocprovider == COLLPROVIDER_ICU)

1167 else if (dbform->datlocprovider == COLLPROVIDER_LIBC)

1170 else

1171

1173

1176

1178}

#define HeapTupleIsValid(tuple)

static void * GETSTRUCT(const HeapTupleData *tuple)

MemoryContext TopMemoryContext

FormData_pg_database * Form_pg_database

pg_locale_t create_pg_locale_libc(Oid collid, MemoryContext context)

pg_locale_t create_pg_locale_builtin(Oid collid, MemoryContext context)

#define PGLOCALE_SUPPORT_ERROR(provider)

pg_locale_t create_pg_locale_icu(Oid collid, MemoryContext context)

static pg_locale_t default_locale

static Datum ObjectIdGetDatum(Oid X)

void ReleaseSysCache(HeapTuple tuple)

HeapTuple SearchSysCache1(int cacheId, Datum key1)

References Assert(), create_pg_locale_builtin(), create_pg_locale_icu(), create_pg_locale_libc(), default_locale, elog, ERROR, GETSTRUCT(), HeapTupleIsValid, pg_locale_struct::is_default, MyDatabaseId, ObjectIdGetDatum(), PGLOCALE_SUPPORT_ERROR, ReleaseSysCache(), SearchSysCache1(), and TopMemoryContext.

Referenced by CheckMyDatabase().

◆ pg_newlocale_from_collation()

Definition at line 1189 of file pg_locale.c.

1190{

1192 bool found;

1193

1194 if (collid == DEFAULT_COLLATION_OID)

1196

1198 elog(ERROR, "cache lookup failed for collation %u", collid);

1199

1201

1204

1206 {

1208 "collation cache",

1211 16, NULL);

1212 }

1213

1215 if (!found)

1216 {

1217

1218

1219

1220

1221 cache_entry->locale = 0;

1222 }

1223

1224 if (cache_entry->locale == 0)

1225 {

1227 }

1228

1231

1232 return cache_entry->locale;

1233}

#define OidIsValid(objectId)

#define AllocSetContextCreate

#define ALLOCSET_DEFAULT_SIZES

static pg_locale_t last_collation_cache_locale

static pg_locale_t create_pg_locale(Oid collid, MemoryContext context)

static MemoryContext CollationCacheContext

static collation_cache_hash * CollationCache

static Oid last_collation_cache_oid

static void AssertCouldGetRelation(void)

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AssertCouldGetRelation(), CollationCache, CollationCacheContext, collid, create_pg_locale(), default_locale, elog, ERROR, last_collation_cache_locale, last_collation_cache_oid, collation_cache_entry::locale, OidIsValid, and TopMemoryContext.

Referenced by bpchareq(), bpcharne(), btvarstrequalimage(), convert_string_datum(), DefineCollation(), Generic_Text_IC_like(), GenericMatchText(), hashbpchar(), hashbpcharextended(), hashtext(), hashtextextended(), like_fixed_prefix(), make_greater_string(), match_pattern_prefix(), pg_set_regex_collation(), spg_text_inner_consistent(), str_casefold(), str_initcap(), str_tolower(), str_toupper(), text_position(), text_position_setup(), text_starts_with(), texteq(), textne(), varstr_cmp(), and varstr_sortsupport().

◆ pg_perm_setlocale()

Definition at line 191 of file pg_locale.c.

192{

193 char *result;

194 const char *envvar;

195

196#ifndef WIN32

198#else

199

200

201

202

203

204

205

206#ifdef LC_MESSAGES

207 if (category == LC_MESSAGES)

208 {

209 result = (char *) locale;

211 return result;

212 }

213 else

214#endif

216#endif

217

218 if (result == NULL)

219 return result;

220

221

222

223

224

225

226

227

228 if (category == LC_CTYPE)

229 {

231

232

233 strlcpy(save_lc_ctype, result, sizeof(save_lc_ctype));

234 result = save_lc_ctype;

235

236#ifdef ENABLE_NLS

238#else

240#endif

241 }

242

243 switch (category)

244 {

245 case LC_COLLATE:

246 envvar = "LC_COLLATE";

247 break;

248 case LC_CTYPE:

249 envvar = "LC_CTYPE";

250 break;

251#ifdef LC_MESSAGES

252 case LC_MESSAGES:

253 envvar = "LC_MESSAGES";

254#ifdef WIN32

255 result = IsoLocaleName(locale);

256 if (result == NULL)

257 result = (char *) locale;

258 elog(DEBUG3, "IsoLocaleName() executed; locale: \"%s\"", result);

259#endif

260 break;

261#endif

262 case LC_MONETARY:

263 envvar = "LC_MONETARY";

264 break;

265 case LC_NUMERIC:

266 envvar = "LC_NUMERIC";

267 break;

268 case LC_TIME:

269 envvar = "LC_TIME";

270 break;

271 default:

272 elog(FATAL, "unrecognized LC category: %d", category);

273 return NULL;

274 }

275

276 if (setenv(envvar, result, 1) != 0)

277 return NULL;

278

279 return result;

280}

void SetMessageEncoding(int encoding)

#define LOCALE_NAME_BUFLEN

size_t strlcpy(char *dst, const char *src, size_t siz)

References DEBUG3, elog, FATAL, GetDatabaseEncoding(), locale, LOCALE_NAME_BUFLEN, setenv, setlocale, SetMessageEncoding(), and strlcpy().

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

◆ pg_strcoll()

◆ pg_strfold()

Definition at line 1314 of file pg_locale.c.

1316{

1317 if (locale->provider == COLLPROVIDER_BUILTIN)

1319#ifdef USE_ICU

1320 else if (locale->provider == COLLPROVIDER_ICU)

1322#endif

1323

1324 else if (locale->provider == COLLPROVIDER_LIBC)

1326 else

1327

1329

1330 return 0;

1331}

size_t strfold_icu(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strlower_libc(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strfold_builtin(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

References locale, PGLOCALE_SUPPORT_ERROR, strfold_builtin(), strfold_icu(), and strlower_libc().

Referenced by str_casefold().

◆ pg_strlower()

Definition at line 1257 of file pg_locale.c.

1259{

1260 if (locale->provider == COLLPROVIDER_BUILTIN)

1262#ifdef USE_ICU

1263 else if (locale->provider == COLLPROVIDER_ICU)

1265#endif

1266 else if (locale->provider == COLLPROVIDER_LIBC)

1268 else

1269

1271

1272 return 0;

1273}

size_t strlower_icu(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strlower_builtin(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

References locale, PGLOCALE_SUPPORT_ERROR, strlower_builtin(), strlower_icu(), and strlower_libc().

Referenced by str_tolower().

◆ pg_strncoll()

◆ pg_strnxfrm()

◆ pg_strnxfrm_prefix()

◆ pg_strtitle()

Definition at line 1276 of file pg_locale.c.

1278{

1279 if (locale->provider == COLLPROVIDER_BUILTIN)

1281#ifdef USE_ICU

1282 else if (locale->provider == COLLPROVIDER_ICU)

1284#endif

1285 else if (locale->provider == COLLPROVIDER_LIBC)

1287 else

1288

1290

1291 return 0;

1292}

size_t strtitle_libc(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strtitle_icu(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strtitle_builtin(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

References locale, PGLOCALE_SUPPORT_ERROR, strtitle_builtin(), strtitle_icu(), and strtitle_libc().

Referenced by str_initcap().

◆ pg_strupper()

Definition at line 1295 of file pg_locale.c.

1297{

1298 if (locale->provider == COLLPROVIDER_BUILTIN)

1300#ifdef USE_ICU

1301 else if (locale->provider == COLLPROVIDER_ICU)

1303#endif

1304 else if (locale->provider == COLLPROVIDER_LIBC)

1306 else

1307

1309

1310 return 0;

1311}

size_t strupper_icu(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strupper_libc(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

size_t strupper_builtin(char *dst, size_t dstsize, const char *src, ssize_t srclen, pg_locale_t locale)

References locale, PGLOCALE_SUPPORT_ERROR, strupper_builtin(), strupper_icu(), and strupper_libc().

Referenced by str_toupper().

◆ pg_strxfrm()

◆ pg_strxfrm_enabled()

◆ pg_strxfrm_prefix()

◆ pg_strxfrm_prefix_enabled()

◆ PGLC_localeconv()

Definition at line 525 of file pg_locale.c.

526{

527 static struct lconv CurrentLocaleConv;

528 static bool CurrentLocaleConvAllocated = false;

529 struct lconv *extlconv;

530 struct lconv tmp;

531 struct lconv worklconv = {0};

532

533

535 return &CurrentLocaleConv;

536

537

538 if (CurrentLocaleConvAllocated)

539 {

541 CurrentLocaleConvAllocated = false;

542 }

543

544

545

546

547

550 &tmp) != 0)

552 "could not get lconv for LC_MONETARY = \"%s\", LC_NUMERIC = \"%s\": %m",

554

555

556 extlconv = &tmp;

557 worklconv.decimal_point = strdup(extlconv->decimal_point);

558 worklconv.thousands_sep = strdup(extlconv->thousands_sep);

559 worklconv.grouping = strdup(extlconv->grouping);

560 worklconv.int_curr_symbol = strdup(extlconv->int_curr_symbol);

561 worklconv.currency_symbol = strdup(extlconv->currency_symbol);

562 worklconv.mon_decimal_point = strdup(extlconv->mon_decimal_point);

563 worklconv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);

564 worklconv.mon_grouping = strdup(extlconv->mon_grouping);

565 worklconv.positive_sign = strdup(extlconv->positive_sign);

566 worklconv.negative_sign = strdup(extlconv->negative_sign);

567

568 worklconv.int_frac_digits = extlconv->int_frac_digits;

569 worklconv.frac_digits = extlconv->frac_digits;

570 worklconv.p_cs_precedes = extlconv->p_cs_precedes;

571 worklconv.p_sep_by_space = extlconv->p_sep_by_space;

572 worklconv.n_cs_precedes = extlconv->n_cs_precedes;

573 worklconv.n_sep_by_space = extlconv->n_sep_by_space;

574 worklconv.p_sign_posn = extlconv->p_sign_posn;

575 worklconv.n_sign_posn = extlconv->n_sign_posn;

576

577

579

580

583 (errcode(ERRCODE_OUT_OF_MEMORY),

584 errmsg("out of memory")));

585

587 {

589

590

591

592

593

594

595

596

600

603

604

608

613

616 }

618 {

621 }

623

624

625

626

627 CurrentLocaleConv = worklconv;

628 CurrentLocaleConvAllocated = true;

630 return &CurrentLocaleConv;

631}

static void db_encoding_convert(int encoding, char **str)

static void free_struct_lconv(struct lconv *s)

static bool CurrentLocaleConvValid

static bool struct_lconv_is_valid(struct lconv *s)

int pg_localeconv_r(const char *lc_monetary, const char *lc_numeric, struct lconv *output)

void pg_localeconv_free(struct lconv *lconv)

References CurrentLocaleConvValid, db_encoding_convert(), elog, encoding, ereport, errcode(), errmsg(), ERROR, free_struct_lconv(), locale_monetary, locale_numeric, PG_CATCH, PG_END_TRY, pg_get_encoding_from_locale(), pg_localeconv_free(), pg_localeconv_r(), PG_RE_THROW, PG_SQL_ASCII, PG_TRY, and struct_lconv_is_valid().

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

◆ report_newlocale_failure()

Definition at line 804 of file pg_locale_libc.c.

805{

806 int save_errno;

807

808

809

810

811

812

813

814

815 if (errno == 0)

816 errno = ENOENT;

817

818

819

820

821

822 save_errno = errno;

824 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

825 errmsg("could not create locale \"%s\": %m",

826 localename),

827 (save_errno == ENOENT ?

828 errdetail("The operating system could not find any locale data for the locale name \"%s\".",

829 localename) : 0)));

830}

int errdetail(const char *fmt,...)

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

Referenced by cache_locale_time(), and make_libc_collator().

◆ wchar2char()

Definition at line 882 of file pg_locale_libc.c.

883{

884 size_t result;

885

886 if (tolen == 0)

887 return 0;

888

889#ifdef WIN32

890

891

892

893

894

895

897 {

898 result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,

899 NULL, NULL);

900

901 if (result <= 0)

902 result = -1;

903 else

904 {

905 Assert(result <= tolen);

906

907 result--;

908 }

909 }

910 else

911#endif

913 {

914

915 result = wcstombs(to, from, tolen);

916 }

917 else

918 {

919

921 }

922

923 return result;

924}

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

References Assert(), GetDatabaseEncoding(), locale, PG_UTF8, and wcstombs_l().

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

◆ database_ctype_is_c

◆ icu_validation_level

◆ locale_messages

◆ locale_monetary

◆ locale_numeric

◆ locale_time

◆ localized_abbrev_days

◆ localized_abbrev_months

◆ localized_full_days

◆ localized_full_months