1 #include <locale.h> 2 #include <langinfo.h> 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <wctype.h> 6 #include <string.h> 7 #include <stdint.h> 8 9 static const char *_empty_str = ""; 10 static const char *_C_name = "C"; 11 12 static wchar_t* _ToWChar(const char* buf, wchar_t *wbuf, size_t wbufSize) { 13 wchar_t *wcur = wbuf; 14 wchar_t *wend = wbuf + wbufSize - 1; 15 for (; wcur != wend && *buf != 0; ++buf, ++wcur) 16 *wcur = *buf; 17 *wcur = 0; 18 return wbuf; 19 } 20 21 #if 0 22 struct _Locale_ctype 23 { 24 locale_t __cloc; 25 }; 26 27 struct _Locale_numeric 28 { 29 locale_t __cloc; 30 }; 31 32 struct _Locale_time 33 { 34 locale_t __cloc; 35 }; 36 37 struct _Locale_collate 38 { 39 locale_t __cloc; 40 }; 41 42 struct _Locale_monetary 43 { 44 locale_t __cloc; 45 }; 46 47 struct _Locale_messages 48 { 49 locale_t __cloc; 50 }; 51 #endif 52 53 void _Locale_init() 54 {} 55 56 void _Locale_final() 57 {} 58 59 struct _Locale_ctype *_Locale_ctype_create(const char *nm, struct _Locale_name_hint* hint, 60 int *__err_code) { 61 *__err_code = _STLP_LOC_UNKNOWN_NAME; 62 return (struct _Locale_ctype*)newlocale(LC_CTYPE_MASK, nm, NULL); 63 } 64 65 struct _Locale_codecvt *_Locale_codecvt_create(const char *nm, struct _Locale_name_hint* hint, 66 int *__err_code) { 67 // Glibc do not support multibyte manipulation for the moment, it simply implements "C". 68 if (nm[0] == 'C' && nm[1] == 0) 69 { return (struct _Locale_codecvt*)0x01; } 70 *__err_code = _STLP_LOC_NO_PLATFORM_SUPPORT; return 0; 71 } 72 73 struct _Locale_numeric *_Locale_numeric_create(const char *nm, struct _Locale_name_hint* hint, 74 int *__err_code) { 75 *__err_code = _STLP_LOC_UNKNOWN_NAME; 76 return (struct _Locale_numeric*)newlocale(LC_NUMERIC_MASK, nm, NULL); 77 } 78 79 struct _Locale_time *_Locale_time_create(const char *nm, struct _Locale_name_hint* hint, 80 int *__err_code) { 81 *__err_code = _STLP_LOC_UNKNOWN_NAME; 82 return (struct _Locale_time*)newlocale(LC_TIME_MASK, nm, NULL); 83 } 84 85 struct _Locale_collate *_Locale_collate_create(const char *nm, struct _Locale_name_hint* hint, 86 int *__err_code) { 87 *__err_code = _STLP_LOC_UNKNOWN_NAME; 88 return (struct _Locale_collate*)newlocale(LC_COLLATE_MASK, nm, NULL); 89 } 90 91 struct _Locale_monetary *_Locale_monetary_create(const char *nm, struct _Locale_name_hint* hint, 92 int *__err_code) { 93 *__err_code = _STLP_LOC_UNKNOWN_NAME; 94 return (struct _Locale_monetary*)newlocale(LC_MONETARY_MASK, nm, NULL); 95 } 96 97 struct _Locale_messages *_Locale_messages_create(const char *nm, struct _Locale_name_hint* hint, 98 int *__err_code) { 99 *__err_code = _STLP_LOC_UNKNOWN_NAME; 100 return (struct _Locale_messages*)newlocale(LC_MESSAGES_MASK, nm, NULL); 101 } 102 103 /* 104 try to see locale category LC should be used from environment; 105 according POSIX, the order is 106 1. LC_ALL 107 2. category (LC_CTYPE, LC_NUMERIC, ... ) 108 3. LANG 109 If set nothing, return "C" (this really implementation-specific). 110 */ 111 static const char *_Locale_aux_default( const char *LC, char *nm ) 112 { 113 char *name = getenv( "LC_ALL" ); 114 115 if ( name != NULL && *name != 0 ) { 116 return name; 117 } 118 name = getenv( LC ); 119 if ( name != NULL && *name != 0 ) { 120 return name; 121 } 122 name = getenv( "LANG" ); 123 if ( name != NULL && *name != 0 ) { 124 return name; 125 } 126 127 return _C_name; 128 } 129 130 const char *_Locale_ctype_default( char *nm ) 131 { 132 return _Locale_aux_default( "LC_CTYPE", nm ); 133 } 134 135 const char *_Locale_numeric_default( char *nm ) 136 { 137 return _Locale_aux_default( "LC_NUMERIC", nm ); 138 } 139 140 const char *_Locale_time_default( char *nm ) 141 { 142 return _Locale_aux_default( "LC_TIME", nm ); 143 } 144 145 const char *_Locale_collate_default( char *nm ) 146 { 147 return _Locale_aux_default( "LC_COLLATE", nm ); 148 } 149 150 const char *_Locale_monetary_default( char *nm ) 151 { 152 return _Locale_aux_default( "LC_MONETARY", nm ); 153 } 154 155 const char *_Locale_messages_default( char *nm ) 156 { 157 return _Locale_aux_default( "LC_MESSAGES", nm ); 158 } 159 160 char const*_Locale_ctype_name( const struct _Locale_ctype *__loc, char *buf ) 161 { 162 return ((locale_t)__loc)->__names[LC_CTYPE]; 163 } 164 165 char const*_Locale_codecvt_name( const struct _Locale_codecvt *__loc, char *buf ) 166 { 167 return _C_name; 168 } 169 170 char const*_Locale_numeric_name( const struct _Locale_numeric *__loc, char *buf ) 171 { 172 return ((locale_t)__loc)->__names[LC_NUMERIC]; 173 } 174 175 char const*_Locale_time_name( const struct _Locale_time *__loc, char *buf ) 176 { 177 return ((locale_t)__loc)->__names[LC_TIME]; 178 } 179 180 char const*_Locale_collate_name( const struct _Locale_collate *__loc, char *buf ) 181 { 182 return ((locale_t)__loc)->__names[LC_COLLATE]; 183 } 184 185 char const*_Locale_monetary_name( const struct _Locale_monetary *__loc, char *buf ) 186 { 187 return ((locale_t)__loc)->__names[LC_MONETARY]; 188 } 189 190 char const*_Locale_messages_name( const struct _Locale_messages *__loc, char *buf ) 191 { 192 return ((locale_t)__loc)->__names[LC_MESSAGES]; 193 } 194 195 void _Locale_ctype_destroy( struct _Locale_ctype *__loc ) 196 { freelocale((locale_t)__loc); } 197 198 void _Locale_codecvt_destroy( struct _Locale_codecvt *__loc ) 199 {} 200 201 void _Locale_numeric_destroy( struct _Locale_numeric *__loc ) 202 { freelocale((locale_t)__loc); } 203 204 void _Locale_time_destroy( struct _Locale_time *__loc ) 205 { freelocale((locale_t)__loc); } 206 207 void _Locale_collate_destroy( struct _Locale_collate *__loc ) 208 { freelocale((locale_t)__loc); } 209 210 void _Locale_monetary_destroy( struct _Locale_monetary *__loc ) 211 { freelocale((locale_t)__loc); } 212 213 void _Locale_messages_destroy( struct _Locale_messages* __loc ) 214 { freelocale((locale_t)__loc); } 215 216 /* 217 * locale loc expected either locale name indeed (platform-specific) 218 * or string like "LC_CTYPE=LocaleNameForCType;LC_NUMERIC=LocaleNameForNum;" 219 * 220 */ 221 222 static char const*__Extract_locale_name( const char *loc, const char *category, char *buf ) 223 { 224 char *expr; 225 size_t len_name; 226 227 if( loc[0]=='L' && loc[1]=='C' && loc[2]=='_') { 228 expr = strstr( (char*)loc, category ); 229 if ( expr == NULL ) 230 return NULL; /* Category not found. */ 231 ++expr; 232 len_name = strcspn( expr, ";" ); 233 len_name = len_name >= _Locale_MAX_SIMPLE_NAME ? _Locale_MAX_SIMPLE_NAME - 1 : len_name; 234 strncpy( buf, expr, len_name ); 235 buf[len_name] = 0; 236 return buf; 237 } 238 return loc; 239 } 240 241 char const*_Locale_extract_ctype_name(const char *loc, char *buf, 242 struct _Locale_name_hint* hint, int *__err_code) 243 { return __Extract_locale_name( loc, "LC_CTYPE=", buf ); } 244 245 char const*_Locale_extract_numeric_name(const char *loc, char *buf, 246 struct _Locale_name_hint* hint, int *__err_code) 247 { return __Extract_locale_name( loc, "LC_NUMERIC=", buf ); } 248 249 char const*_Locale_extract_time_name(const char *loc, char *buf, 250 struct _Locale_name_hint* hint, int *__err_code) 251 { return __Extract_locale_name( loc, "LC_TIME=", buf ); } 252 253 char const*_Locale_extract_collate_name(const char *loc, char *buf, 254 struct _Locale_name_hint* hint, int *__err_code) 255 { return __Extract_locale_name( loc, "LC_COLLATE=", buf ); } 256 257 char const*_Locale_extract_monetary_name(const char *loc, char *buf, 258 struct _Locale_name_hint* hint, int *__err_code) 259 { return __Extract_locale_name( loc, "LC_MONETARY=", buf ); } 260 261 char const*_Locale_extract_messages_name(const char *loc, char *buf, 262 struct _Locale_name_hint* hint, int *__err_code) 263 { return __Extract_locale_name( loc, "LC_MESSAGES=", buf ); } 264 265 struct _Locale_name_hint* _Locale_get_ctype_hint(struct _Locale_ctype* ctype) 266 { return 0; } 267 struct _Locale_name_hint* _Locale_get_numeric_hint(struct _Locale_numeric* numeric) 268 { return 0; } 269 struct _Locale_name_hint* _Locale_get_time_hint(struct _Locale_time* time) 270 { return 0; } 271 struct _Locale_name_hint* _Locale_get_collate_hint(struct _Locale_collate* collate) 272 { return 0; } 273 struct _Locale_name_hint* _Locale_get_monetary_hint(struct _Locale_monetary* monetary) 274 { return 0; } 275 struct _Locale_name_hint* _Locale_get_messages_hint(struct _Locale_messages* messages) 276 { return 0; } 277 278 /* ctype */ 279 280 const _Locale_mask_t *_Locale_ctype_table( struct _Locale_ctype *__loc ) 281 { 282 /* return table with masks (upper, lower, alpha, etc.) */ 283 _STLP_STATIC_ASSERT( sizeof(_Locale_mask_t) == sizeof(((locale_t)__loc)->__ctype_b[0]) ) 284 return ((locale_t)__loc)->__ctype_b; 285 } 286 287 int _Locale_toupper( struct _Locale_ctype *__loc, int c ) 288 { return ((locale_t)__loc)->__ctype_toupper[c]; } 289 290 int _Locale_tolower( struct _Locale_ctype *__loc, int c ) 291 { return ((locale_t)__loc)->__ctype_tolower[c]; } 292 293 #if !defined (_STLP_NO_WCHAR_T) 294 _Locale_mask_t _WLocale_ctype( struct _Locale_ctype *__loc, wint_t wc, _Locale_mask_t __mask ) 295 { 296 _Locale_mask_t ret = 0; 297 if ((__mask & _Locale_ALPHA) != 0 && iswalpha_l(wc, (locale_t)__loc)) 298 ret |= _Locale_ALPHA; 299 300 if ((__mask & _Locale_CNTRL) != 0 && iswcntrl_l(wc, (locale_t)__loc)) 301 ret |= _Locale_CNTRL; 302 303 if ((__mask & _Locale_DIGIT) != 0 && iswdigit_l(wc, (locale_t)__loc)) 304 ret |= _Locale_DIGIT; 305 306 if ((__mask & _Locale_PRINT) != 0 && iswprint_l(wc, (locale_t)__loc)) 307 ret |= _Locale_PRINT; 308 309 if ((__mask & _Locale_PUNCT) != 0 && iswpunct_l(wc, (locale_t)__loc)) 310 ret |= _Locale_PUNCT; 311 312 if ((__mask & _Locale_SPACE) != 0 && iswspace_l(wc, (locale_t)__loc)) 313 ret |= _Locale_SPACE; 314 315 if ((__mask & _Locale_XDIGIT) != 0 && iswxdigit_l(wc, (locale_t)__loc)) 316 ret |= _Locale_XDIGIT; 317 318 if ((__mask & _Locale_UPPER) != 0 && iswupper_l(wc, (locale_t)__loc)) 319 ret |= _Locale_UPPER; 320 321 if ((__mask & _Locale_LOWER) != 0 && iswlower_l(wc, (locale_t)__loc)) 322 ret |= _Locale_LOWER; 323 324 return ret; 325 } 326 327 wint_t _WLocale_tolower( struct _Locale_ctype *__loc, wint_t c ) 328 { 329 return towlower_l( c, ((locale_t)__loc) ); 330 } 331 332 wint_t _WLocale_toupper( struct _Locale_ctype *__loc, wint_t c ) 333 { 334 return towupper_l( c, ((locale_t)__loc) ); 335 } 336 #endif 337 338 int _WLocale_mb_cur_max( struct _Locale_codecvt * lcodecvt) { return 1; } 339 int _WLocale_mb_cur_min( struct _Locale_codecvt * lcodecvt) { return 1; } 340 int _WLocale_is_stateless( struct _Locale_codecvt * lcodecvt) { return 1; } 341 342 #if !defined (_STLP_NO_WCHAR_T) 343 size_t _WLocale_mbtowc(struct _Locale_codecvt *lcodecvt, 344 wchar_t *to, 345 const char *from, size_t n, 346 mbstate_t *st) 347 { *to = *from; return 1; } 348 349 size_t _WLocale_wctomb(struct _Locale_codecvt *lcodecvt, 350 char *to, size_t n, 351 const wchar_t c, 352 mbstate_t *st) 353 { *to = (char)c; return 1; } 354 #endif 355 356 size_t _WLocale_unshift(struct _Locale_codecvt *lcodecvt, 357 mbstate_t *st, 358 char *buf, size_t n, char ** next) 359 { *next = buf; return 0; } 360 361 /* Collate */ 362 int _Locale_strcmp(struct _Locale_collate * __loc, 363 const char *s1, size_t n1, 364 const char *s2, size_t n2) { 365 int ret = 0; 366 char buf1[64], buf2[64]; 367 while (n1 > 0 || n2 > 0) { 368 size_t bufsize1 = n1 < 63 ? n1 : 63; 369 size_t bufsize2 = n2 < 63 ? n2 : 63; 370 strncpy(buf1, s1, bufsize1); buf1[bufsize1] = 0; 371 strncpy(buf2, s2, bufsize2); buf2[bufsize2] = 0; 372 373 ret = strcoll_l(buf1, buf2, (locale_t)__loc); 374 if (ret != 0) return ret; 375 s1 += bufsize1; n1 -= bufsize1; 376 s2 += bufsize2; n2 -= bufsize2; 377 } 378 return ret; 379 } 380 381 #if !defined (_STLP_NO_WCHAR_T) 382 int _WLocale_strcmp(struct _Locale_collate *__loc, 383 const wchar_t *s1, size_t n1, 384 const wchar_t *s2, size_t n2) { 385 int ret = 0; 386 wchar_t buf1[64], buf2[64]; 387 while (n1 > 0 || n2 > 0) { 388 size_t bufsize1 = n1 < 63 ? n1 : 63; 389 size_t bufsize2 = n2 < 63 ? n2 : 63; 390 wcsncpy(buf1, s1, bufsize1); buf1[bufsize1] = 0; 391 wcsncpy(buf2, s2, bufsize2); buf2[bufsize2] = 0; 392 393 ret = wcscoll_l(buf1, buf2, (locale_t)__loc); 394 if (ret != 0) return ret; 395 s1 += bufsize1; n1 -= bufsize1; 396 s2 += bufsize2; n2 -= bufsize2; 397 } 398 return ret; 399 } 400 401 #endif 402 403 size_t _Locale_strxfrm(struct _Locale_collate *__loc, 404 char *dest, size_t dest_n, 405 const char *src, size_t src_n ) 406 { 407 const char *real_src; 408 char *buf = NULL; 409 size_t result; 410 411 if (src_n == 0) 412 { 413 if (dest != NULL) dest[0] = 0; 414 return 0; 415 } 416 if (src[src_n] != 0) { 417 buf = malloc(src_n + 1); 418 strncpy(buf, src, src_n); 419 buf[src_n] = 0; 420 real_src = buf; 421 } 422 else 423 real_src = src; 424 result = strxfrm_l(dest, real_src, dest_n, (locale_t)__loc); 425 if (buf != NULL) free(buf); 426 return result; 427 } 428 429 # ifndef _STLP_NO_WCHAR_T 430 431 size_t _WLocale_strxfrm( struct _Locale_collate *__loc, 432 wchar_t *dest, size_t dest_n, 433 const wchar_t *src, size_t src_n ) 434 { 435 const wchar_t *real_src; 436 wchar_t *buf = NULL; 437 size_t result; 438 439 if (src_n == 0) 440 { 441 if (dest != NULL) dest[0] = 0; 442 return 0; 443 } 444 if (src[src_n] != 0) { 445 buf = malloc((src_n + 1) * sizeof(wchar_t)); 446 wcsncpy(buf, src, src_n); 447 buf[src_n] = 0; 448 real_src = buf; 449 } 450 else 451 real_src = src; 452 result = wcsxfrm_l(dest, real_src, dest_n, (locale_t)__loc); 453 if (buf != NULL) free(buf); 454 return result; 455 } 456 457 # endif 458 459 /* Numeric */ 460 461 char _Locale_decimal_point(struct _Locale_numeric *__loc) 462 { 463 return *(nl_langinfo_l(RADIXCHAR, (locale_t)__loc)); 464 } 465 466 char _Locale_thousands_sep(struct _Locale_numeric *__loc) 467 { 468 return *(nl_langinfo_l(THOUSEP, (locale_t)__loc)); 469 } 470 471 const char* _Locale_grouping(struct _Locale_numeric *__loc) 472 { 473 return (_Locale_thousands_sep(__loc) != 0 ) ? (nl_langinfo_l(GROUPING, (locale_t)__loc)) : _empty_str; 474 } 475 476 const char *_Locale_true(struct _Locale_numeric *__loc) 477 { 478 return nl_langinfo_l(YESSTR, (locale_t)__loc); 479 } 480 481 const char *_Locale_false(struct _Locale_numeric *__loc) 482 { 483 return nl_langinfo_l(NOSTR, (locale_t)__loc); 484 } 485 486 #ifndef _STLP_NO_WCHAR_T 487 wchar_t _WLocale_decimal_point(struct _Locale_numeric *__loc) 488 { return (wchar_t)_Locale_decimal_point(__loc); } 489 wchar_t _WLocale_thousands_sep(struct _Locale_numeric *__loc) 490 { return (wchar_t)_Locale_thousands_sep(__loc); } 491 const wchar_t *_WLocale_true(struct _Locale_numeric *__loc, wchar_t *buf, size_t bufSize) 492 { return _ToWChar(_Locale_true(__loc), buf, bufSize); } 493 const wchar_t *_WLocale_false(struct _Locale_numeric *__loc, wchar_t *buf, size_t bufSize) 494 { return _ToWChar(_Locale_false(__loc), buf, bufSize); } 495 #endif 496 497 /* Monetary */ 498 499 const char *_Locale_int_curr_symbol(struct _Locale_monetary *__loc) 500 { 501 return nl_langinfo_l(INT_CURR_SYMBOL, (locale_t)__loc); 502 } 503 504 const char *_Locale_currency_symbol(struct _Locale_monetary *__loc) 505 { 506 return nl_langinfo_l(CURRENCY_SYMBOL, (locale_t)__loc); 507 } 508 509 char _Locale_mon_decimal_point(struct _Locale_monetary * __loc) 510 { 511 return *(nl_langinfo_l(MON_DECIMAL_POINT,(locale_t)__loc)); 512 } 513 514 char _Locale_mon_thousands_sep(struct _Locale_monetary *__loc) 515 { 516 return *(nl_langinfo_l(MON_THOUSANDS_SEP, (locale_t)__loc)); 517 } 518 519 #ifndef _STLP_NO_WCHAR_T 520 const wchar_t *_WLocale_int_curr_symbol(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize) 521 { return _ToWChar(_Locale_int_curr_symbol(__loc), buf, bufSize); } 522 const wchar_t *_WLocale_currency_symbol(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize) 523 { return _ToWChar(_Locale_currency_symbol(__loc), buf, bufSize); } 524 wchar_t _WLocale_mon_decimal_point(struct _Locale_monetary * __loc) 525 { return (wchar_t)_Locale_mon_decimal_point(__loc); } 526 wchar_t _WLocale_mon_thousands_sep(struct _Locale_monetary * __loc) 527 { return (wchar_t)_Locale_mon_thousands_sep(__loc); } 528 const wchar_t *_WLocale_positive_sign(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize) 529 { return _ToWChar(_Locale_positive_sign(__loc), buf, bufSize); } 530 const wchar_t *_WLocale_negative_sign(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize) 531 { return _ToWChar(_Locale_negative_sign(__loc), buf, bufSize); } 532 #endif 533 534 const char *_Locale_mon_grouping(struct _Locale_monetary *__loc) 535 { 536 return (_Locale_mon_thousands_sep( __loc ) != 0 ) ? nl_langinfo_l(MON_GROUPING, (locale_t)__loc) : _empty_str; 537 } 538 539 const char *_Locale_positive_sign(struct _Locale_monetary *__loc) 540 { 541 return nl_langinfo_l(POSITIVE_SIGN, (locale_t)__loc); 542 } 543 544 const char *_Locale_negative_sign(struct _Locale_monetary *__loc) 545 { 546 return nl_langinfo_l(NEGATIVE_SIGN, (locale_t)__loc); 547 } 548 549 char _Locale_int_frac_digits(struct _Locale_monetary *__loc) 550 { 551 /* We are forced to manually handled the "C" locale for consistency with 552 * the default implementation in STLport. */ 553 const char* lname = ((locale_t)__loc)->__names[LC_MONETARY]; 554 if (lname[0] == 'C' && lname[1] == 0) 555 return 0; 556 return *(nl_langinfo_l(INT_FRAC_DIGITS, (locale_t)__loc)); 557 } 558 559 char _Locale_frac_digits(struct _Locale_monetary *__loc) 560 { 561 /* We are forced to manually handled the "C" locale for consistency with 562 * the default implementation in STLport. */ 563 const char* lname = ((locale_t)__loc)->__names[LC_MONETARY]; 564 if (lname[0] == 'C' && lname[1] == 0) 565 return 0; 566 return *(nl_langinfo_l(FRAC_DIGITS, (locale_t)__loc)); 567 } 568 569 /* 1 if currency_symbol precedes a positive value, 0 if succeeds */ 570 int _Locale_p_cs_precedes(struct _Locale_monetary *__loc) 571 { 572 return *(nl_langinfo_l(P_CS_PRECEDES, (locale_t)__loc)); 573 } 574 575 /* 1 if a space separates currency_symbol from a positive value. */ 576 int _Locale_p_sep_by_space(struct _Locale_monetary *__loc) 577 { 578 return *(nl_langinfo_l(P_SEP_BY_SPACE, (locale_t)__loc)); 579 } 580 581 /* 582 * 0 Parentheses surround the quantity and currency_symbol 583 * 1 The sign string precedes the quantity and currency_symbol 584 * 2 The sign string succeeds the quantity and currency_symbol. 585 * 3 The sign string immediately precedes the currency_symbol. 586 * 4 The sign string immediately succeeds the currency_symbol. 587 */ 588 int _Locale_p_sign_posn(struct _Locale_monetary *__loc) 589 { 590 return *(nl_langinfo_l(P_SIGN_POSN, (locale_t)__loc)); 591 } 592 593 /* 1 if currency_symbol precedes a negative value, 0 if succeeds */ 594 int _Locale_n_cs_precedes(struct _Locale_monetary *__loc) 595 { 596 return *(nl_langinfo_l(N_CS_PRECEDES, (locale_t)__loc)); 597 } 598 599 /* 1 if a space separates currency_symbol from a negative value. */ 600 int _Locale_n_sep_by_space(struct _Locale_monetary *__loc) 601 { 602 return *(nl_langinfo_l(N_SEP_BY_SPACE, (locale_t)__loc)); 603 } 604 605 /* 606 * 0 Parentheses surround the quantity and currency_symbol 607 * 1 The sign string precedes the quantity and currency_symbol 608 * 2 The sign string succeeds the quantity and currency_symbol. 609 * 3 The sign string immediately precedes the currency_symbol. 610 * 4 The sign string immediately succeeds the currency_symbol. 611 */ 612 int _Locale_n_sign_posn(struct _Locale_monetary *__loc) 613 { 614 return *(nl_langinfo_l(N_SIGN_POSN, (locale_t)__loc)); 615 } 616 617 618 /* Time */ 619 const char *_Locale_full_monthname(struct _Locale_time *__loc, int _m ) 620 { 621 return nl_langinfo_l(MON_1 + _m, (locale_t)__loc); 622 } 623 624 const char *_Locale_abbrev_monthname(struct _Locale_time *__loc, int _m ) 625 { 626 return nl_langinfo_l(ABMON_1 + _m, (locale_t)__loc); 627 } 628 629 const char *_Locale_full_dayofweek(struct _Locale_time *__loc, int _d ) 630 { 631 return nl_langinfo_l(DAY_1 + _d, (locale_t)__loc); 632 } 633 634 const char *_Locale_abbrev_dayofweek(struct _Locale_time *__loc, int _d ) 635 { 636 return nl_langinfo_l(ABDAY_1 + _d, (locale_t)__loc); 637 } 638 639 const char *_Locale_d_t_fmt(struct _Locale_time *__loc) 640 { 641 return nl_langinfo_l(D_T_FMT, (locale_t)__loc); 642 } 643 644 const char *_Locale_d_fmt(struct _Locale_time *__loc ) 645 { 646 return nl_langinfo_l(D_FMT, (locale_t)__loc); 647 } 648 649 const char *_Locale_t_fmt(struct _Locale_time *__loc ) 650 { 651 return nl_langinfo_l(T_FMT, (locale_t)__loc); 652 } 653 654 const char *_Locale_long_d_t_fmt(struct _Locale_time *__loc ) 655 { 656 return nl_langinfo_l(ERA_D_T_FMT, (locale_t)__loc); 657 } 658 659 const char *_Locale_long_d_fmt(struct _Locale_time *__loc ) 660 { 661 return nl_langinfo_l(ERA_D_FMT, (locale_t)__loc); 662 } 663 664 const char *_Locale_am_str(struct _Locale_time *__loc ) 665 { 666 return nl_langinfo_l(AM_STR, (locale_t)__loc); 667 } 668 669 const char *_Locale_pm_str(struct _Locale_time* __loc ) 670 { 671 return nl_langinfo_l(PM_STR, (locale_t)__loc); 672 } 673 674 #ifndef _STLP_NO_WCHAR_T 675 const wchar_t *_WLocale_full_monthname(struct _Locale_time *__loc, int _m, wchar_t *buf, size_t bufSize) 676 { return _ToWChar(_Locale_full_monthname(__loc, _m), buf, bufSize); } 677 const wchar_t *_WLocale_abbrev_monthname(struct _Locale_time *__loc, int _m, wchar_t *buf, size_t bufSize) 678 { return _ToWChar(_Locale_abbrev_monthname(__loc, _m), buf, bufSize); } 679 const wchar_t *_WLocale_full_dayofweek(struct _Locale_time *__loc, int _d, wchar_t *buf, size_t bufSize) 680 { return _ToWChar(_Locale_full_dayofweek(__loc, _d), buf, bufSize); } 681 const wchar_t *_WLocale_abbrev_dayofweek(struct _Locale_time *__loc, int _d, wchar_t *buf, size_t bufSize) 682 { return _ToWChar(_Locale_abbrev_dayofweek(__loc, _d), buf, bufSize); } 683 const wchar_t *_WLocale_am_str(struct _Locale_time *__loc, wchar_t *buf, size_t bufSize) 684 { return _ToWChar(_Locale_am_str(__loc), buf, bufSize); } 685 const wchar_t *_WLocale_pm_str(struct _Locale_time* __loc, wchar_t *buf, size_t bufSize) 686 { return _ToWChar(_Locale_pm_str(__loc), buf, bufSize); } 687 #endif 688 689 /* Messages */ 690 691 nl_catd_type _Locale_catopen(struct _Locale_messages *__loc, const char *__cat_name ) 692 { 693 return catopen( __cat_name, NL_CAT_LOCALE ); 694 } 695 696 void _Locale_catclose(struct _Locale_messages *__loc, nl_catd_type __cat ) 697 { 698 catclose( __cat ); 699 } 700 701 const char *_Locale_catgets(struct _Locale_messages *__loc, nl_catd_type __cat, 702 int __setid, int __msgid, const char *dfault) 703 { 704 return catgets( __cat, __setid, __msgid, dfault ); 705 } 706