1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ********************************************************************** 5 * Copyright (C) 1997-2016, International Business Machines 6 * Corporation and others. All Rights Reserved. 7 ********************************************************************** 8 * 9 * File locid.cpp 10 * 11 * Created by: Richard Gillam 12 * 13 * Modification History: 14 * 15 * Date Name Description 16 * 02/11/97 aliu Changed gLocPath to fgDataDirectory and added 17 * methods to get and set it. 18 * 04/02/97 aliu Made operator!= inline; fixed return value 19 * of getName(). 20 * 04/15/97 aliu Cleanup for AIX/Win32. 21 * 04/24/97 aliu Numerous changes per code review. 22 * 08/18/98 stephen Changed getDisplayName() 23 * Added SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE 24 * Added getISOCountries(), getISOLanguages(), 25 * getLanguagesForCountry() 26 * 03/16/99 bertrand rehaul. 27 * 07/21/99 stephen Added U_CFUNC setDefault 28 * 11/09/99 weiv Added const char * getName() const; 29 * 04/12/00 srl removing unicodestring api's and cached hash code 30 * 08/10/01 grhoten Change the static Locales to accessor functions 31 ****************************************************************************** 32 */ 33 34 35 #include "unicode/locid.h" 36 #include "unicode/strenum.h" 37 #include "unicode/uloc.h" 38 #include "putilimp.h" 39 #include "mutex.h" 40 #include "umutex.h" 41 #include "uassert.h" 42 #include "cmemory.h" 43 #include "cstring.h" 44 #include "uassert.h" 45 #include "uhash.h" 46 #include "ucln_cmn.h" 47 #include "ustr_imp.h" 48 #include "charstr.h" 49 50 U_CDECL_BEGIN 51 static UBool U_CALLCONV locale_cleanup(void); 52 U_CDECL_END 53 54 U_NAMESPACE_BEGIN 55 56 static Locale *gLocaleCache = NULL; 57 static UInitOnce gLocaleCacheInitOnce = U_INITONCE_INITIALIZER; 58 59 // gDefaultLocaleMutex protects all access to gDefaultLocalesHashT and gDefaultLocale. 60 static UMutex gDefaultLocaleMutex = U_MUTEX_INITIALIZER; 61 static UHashtable *gDefaultLocalesHashT = NULL; 62 static Locale *gDefaultLocale = NULL; 63 64 /** 65 * \def ULOC_STRING_LIMIT 66 * strings beyond this value crash in CharString 67 */ 68 #define ULOC_STRING_LIMIT 357913941 69 70 U_NAMESPACE_END 71 72 typedef enum ELocalePos { 73 eENGLISH, 74 eFRENCH, 75 eGERMAN, 76 eITALIAN, 77 eJAPANESE, 78 eKOREAN, 79 eCHINESE, 80 81 eFRANCE, 82 eGERMANY, 83 eITALY, 84 eJAPAN, 85 eKOREA, 86 eCHINA, /* Alias for PRC */ 87 eTAIWAN, 88 eUK, 89 eUS, 90 eCANADA, 91 eCANADA_FRENCH, 92 eROOT, 93 94 95 //eDEFAULT, 96 eMAX_LOCALES 97 } ELocalePos; 98 99 U_CFUNC int32_t locale_getKeywords(const char *localeID, 100 char prev, 101 char *keywords, int32_t keywordCapacity, 102 char *values, int32_t valuesCapacity, int32_t *valLen, 103 UBool valuesToo, 104 UErrorCode *status); 105 106 U_CDECL_BEGIN 107 // 108 // Deleter function for Locales owned by the default Locale hash table/ 109 // 110 static void U_CALLCONV 111 deleteLocale(void *obj) { 112 delete (icu::Locale *) obj; 113 } 114 115 static UBool U_CALLCONV locale_cleanup(void) 116 { 117 U_NAMESPACE_USE 118 119 delete [] gLocaleCache; 120 gLocaleCache = NULL; 121 gLocaleCacheInitOnce.reset(); 122 123 if (gDefaultLocalesHashT) { 124 uhash_close(gDefaultLocalesHashT); // Automatically deletes all elements, using deleter func. 125 gDefaultLocalesHashT = NULL; 126 } 127 gDefaultLocale = NULL; 128 return TRUE; 129 } 130 131 132 static void U_CALLCONV locale_init(UErrorCode &status) { 133 U_NAMESPACE_USE 134 135 U_ASSERT(gLocaleCache == NULL); 136 gLocaleCache = new Locale[(int)eMAX_LOCALES]; 137 if (gLocaleCache == NULL) { 138 status = U_MEMORY_ALLOCATION_ERROR; 139 return; 140 } 141 ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); 142 gLocaleCache[eROOT] = Locale(""); 143 gLocaleCache[eENGLISH] = Locale("en"); 144 gLocaleCache[eFRENCH] = Locale("fr"); 145 gLocaleCache[eGERMAN] = Locale("de"); 146 gLocaleCache[eITALIAN] = Locale("it"); 147 gLocaleCache[eJAPANESE] = Locale("ja"); 148 gLocaleCache[eKOREAN] = Locale("ko"); 149 gLocaleCache[eCHINESE] = Locale("zh"); 150 gLocaleCache[eFRANCE] = Locale("fr", "FR"); 151 gLocaleCache[eGERMANY] = Locale("de", "DE"); 152 gLocaleCache[eITALY] = Locale("it", "IT"); 153 gLocaleCache[eJAPAN] = Locale("ja", "JP"); 154 gLocaleCache[eKOREA] = Locale("ko", "KR"); 155 gLocaleCache[eCHINA] = Locale("zh", "CN"); 156 gLocaleCache[eTAIWAN] = Locale("zh", "TW"); 157 gLocaleCache[eUK] = Locale("en", "GB"); 158 gLocaleCache[eUS] = Locale("en", "US"); 159 gLocaleCache[eCANADA] = Locale("en", "CA"); 160 gLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA"); 161 } 162 163 U_CDECL_END 164 165 U_NAMESPACE_BEGIN 166 167 Locale *locale_set_default_internal(const char *id, UErrorCode& status) { 168 // Synchronize this entire function. 169 Mutex lock(&gDefaultLocaleMutex); 170 171 UBool canonicalize = FALSE; 172 173 // If given a NULL string for the locale id, grab the default 174 // name from the system. 175 // (Different from most other locale APIs, where a null name means use 176 // the current ICU default locale.) 177 if (id == NULL) { 178 id = uprv_getDefaultLocaleID(); // This function not thread safe? TODO: verify. 179 canonicalize = TRUE; // always canonicalize host ID 180 } 181 182 char localeNameBuf[512]; 183 184 if (canonicalize) { 185 uloc_canonicalize(id, localeNameBuf, sizeof(localeNameBuf)-1, &status); 186 } else { 187 uloc_getName(id, localeNameBuf, sizeof(localeNameBuf)-1, &status); 188 } 189 localeNameBuf[sizeof(localeNameBuf)-1] = 0; // Force null termination in event of 190 // a long name filling the buffer. 191 // (long names are truncated.) 192 // 193 if (U_FAILURE(status)) { 194 return gDefaultLocale; 195 } 196 197 if (gDefaultLocalesHashT == NULL) { 198 gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status); 199 if (U_FAILURE(status)) { 200 return gDefaultLocale; 201 } 202 uhash_setValueDeleter(gDefaultLocalesHashT, deleteLocale); 203 ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); 204 } 205 206 Locale *newDefault = (Locale *)uhash_get(gDefaultLocalesHashT, localeNameBuf); 207 if (newDefault == NULL) { 208 newDefault = new Locale(Locale::eBOGUS); 209 if (newDefault == NULL) { 210 status = U_MEMORY_ALLOCATION_ERROR; 211 return gDefaultLocale; 212 } 213 newDefault->init(localeNameBuf, FALSE); 214 uhash_put(gDefaultLocalesHashT, (char*) newDefault->getName(), newDefault, &status); 215 if (U_FAILURE(status)) { 216 return gDefaultLocale; 217 } 218 } 219 gDefaultLocale = newDefault; 220 return gDefaultLocale; 221 } 222 223 U_NAMESPACE_END 224 225 /* sfb 07/21/99 */ 226 U_CFUNC void 227 locale_set_default(const char *id) 228 { 229 U_NAMESPACE_USE 230 UErrorCode status = U_ZERO_ERROR; 231 locale_set_default_internal(id, status); 232 } 233 /* end */ 234 235 U_CFUNC const char * 236 locale_get_default(void) 237 { 238 U_NAMESPACE_USE 239 return Locale::getDefault().getName(); 240 } 241 242 243 U_NAMESPACE_BEGIN 244 245 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale) 246 247 /*Character separating the posix id fields*/ 248 // '_' 249 // In the platform codepage. 250 #define SEP_CHAR '_' 251 252 Locale::~Locale() 253 { 254 if (baseName != fullName) { 255 uprv_free(baseName); 256 } 257 baseName = NULL; 258 /*if fullName is on the heap, we free it*/ 259 if (fullName != fullNameBuffer) 260 { 261 uprv_free(fullName); 262 fullName = NULL; 263 } 264 } 265 266 Locale::Locale() 267 : UObject(), fullName(fullNameBuffer), baseName(NULL) 268 { 269 init(NULL, FALSE); 270 } 271 272 /* 273 * Internal constructor to allow construction of a locale object with 274 * NO side effects. (Default constructor tries to get 275 * the default locale.) 276 */ 277 Locale::Locale(Locale::ELocaleType) 278 : UObject(), fullName(fullNameBuffer), baseName(NULL) 279 { 280 setToBogus(); 281 } 282 283 284 Locale::Locale( const char * newLanguage, 285 const char * newCountry, 286 const char * newVariant, 287 const char * newKeywords) 288 : UObject(), fullName(fullNameBuffer), baseName(NULL) 289 { 290 if( (newLanguage==NULL) && (newCountry == NULL) && (newVariant == NULL) ) 291 { 292 init(NULL, FALSE); /* shortcut */ 293 } 294 else 295 { 296 UErrorCode status = U_ZERO_ERROR; 297 int32_t size = 0; 298 int32_t lsize = 0; 299 int32_t csize = 0; 300 int32_t vsize = 0; 301 int32_t ksize = 0; 302 303 // Calculate the size of the resulting string. 304 305 // Language 306 if ( newLanguage != NULL ) 307 { 308 lsize = (int32_t)uprv_strlen(newLanguage); 309 if ( lsize < 0 || lsize > ULOC_STRING_LIMIT ) { // int32 wrap 310 setToBogus(); 311 return; 312 } 313 size = lsize; 314 } 315 316 CharString togo(newLanguage, lsize, status); // start with newLanguage 317 318 // _Country 319 if ( newCountry != NULL ) 320 { 321 csize = (int32_t)uprv_strlen(newCountry); 322 if ( csize < 0 || csize > ULOC_STRING_LIMIT ) { // int32 wrap 323 setToBogus(); 324 return; 325 } 326 size += csize; 327 } 328 329 // _Variant 330 if ( newVariant != NULL ) 331 { 332 // remove leading _'s 333 while(newVariant[0] == SEP_CHAR) 334 { 335 newVariant++; 336 } 337 338 // remove trailing _'s 339 vsize = (int32_t)uprv_strlen(newVariant); 340 if ( vsize < 0 || vsize > ULOC_STRING_LIMIT ) { // int32 wrap 341 setToBogus(); 342 return; 343 } 344 while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) ) 345 { 346 vsize--; 347 } 348 } 349 350 if( vsize > 0 ) 351 { 352 size += vsize; 353 } 354 355 // Separator rules: 356 if ( vsize > 0 ) 357 { 358 size += 2; // at least: __v 359 } 360 else if ( csize > 0 ) 361 { 362 size += 1; // at least: _v 363 } 364 365 if ( newKeywords != NULL) 366 { 367 ksize = (int32_t)uprv_strlen(newKeywords); 368 if ( ksize < 0 || ksize > ULOC_STRING_LIMIT ) { 369 setToBogus(); 370 return; 371 } 372 size += ksize + 1; 373 } 374 375 // NOW we have the full locale string.. 376 // Now, copy it back. 377 378 // newLanguage is already copied 379 380 if ( ( vsize != 0 ) || (csize != 0) ) // at least: __v 381 { // ^ 382 togo.append(SEP_CHAR, status); 383 } 384 385 if ( csize != 0 ) 386 { 387 togo.append(newCountry, status); 388 } 389 390 if ( vsize != 0) 391 { 392 togo.append(SEP_CHAR, status) 393 .append(newVariant, vsize, status); 394 } 395 396 if ( ksize != 0) 397 { 398 if (uprv_strchr(newKeywords, '=')) { 399 togo.append('@', status); /* keyword parsing */ 400 } 401 else { 402 togo.append('_', status); /* Variant parsing with a script */ 403 if ( vsize == 0) { 404 togo.append('_', status); /* No country found */ 405 } 406 } 407 togo.append(newKeywords, status); 408 } 409 410 if (U_FAILURE(status)) { 411 // Something went wrong with appending, etc. 412 setToBogus(); 413 return; 414 } 415 // Parse it, because for example 'language' might really be a complete 416 // string. 417 init(togo.data(), FALSE); 418 } 419 } 420 421 Locale::Locale(const Locale &other) 422 : UObject(other), fullName(fullNameBuffer), baseName(NULL) 423 { 424 *this = other; 425 } 426 427 Locale &Locale::operator=(const Locale &other) 428 { 429 if (this == &other) { 430 return *this; 431 } 432 433 /* Free our current storage */ 434 if (baseName != fullName) { 435 uprv_free(baseName); 436 } 437 baseName = NULL; 438 if(fullName != fullNameBuffer) { 439 uprv_free(fullName); 440 fullName = fullNameBuffer; 441 } 442 443 /* Allocate the full name if necessary */ 444 if(other.fullName != other.fullNameBuffer) { 445 fullName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(other.fullName)+1)); 446 if (fullName == NULL) { 447 return *this; 448 } 449 } 450 /* Copy the full name */ 451 uprv_strcpy(fullName, other.fullName); 452 453 /* Copy the baseName if it differs from fullName. */ 454 if (other.baseName == other.fullName) { 455 baseName = fullName; 456 } else { 457 if (other.baseName) { 458 baseName = uprv_strdup(other.baseName); 459 } 460 } 461 462 /* Copy the language and country fields */ 463 uprv_strcpy(language, other.language); 464 uprv_strcpy(script, other.script); 465 uprv_strcpy(country, other.country); 466 467 /* The variantBegin is an offset, just copy it */ 468 variantBegin = other.variantBegin; 469 fIsBogus = other.fIsBogus; 470 return *this; 471 } 472 473 Locale * 474 Locale::clone() const { 475 return new Locale(*this); 476 } 477 478 UBool 479 Locale::operator==( const Locale& other) const 480 { 481 return (uprv_strcmp(other.fullName, fullName) == 0); 482 } 483 484 #define ISASCIIALPHA(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z')) 485 486 /*This function initializes a Locale from a C locale ID*/ 487 Locale& Locale::init(const char* localeID, UBool canonicalize) 488 { 489 fIsBogus = FALSE; 490 /* Free our current storage */ 491 if (baseName != fullName) { 492 uprv_free(baseName); 493 } 494 baseName = NULL; 495 if(fullName != fullNameBuffer) { 496 uprv_free(fullName); 497 fullName = fullNameBuffer; 498 } 499 500 // not a loop: 501 // just an easy way to have a common error-exit 502 // without goto and without another function 503 do { 504 char *separator; 505 char *field[5] = {0}; 506 int32_t fieldLen[5] = {0}; 507 int32_t fieldIdx; 508 int32_t variantField; 509 int32_t length; 510 UErrorCode err; 511 512 if(localeID == NULL) { 513 // not an error, just set the default locale 514 return *this = getDefault(); 515 } 516 517 /* preset all fields to empty */ 518 language[0] = script[0] = country[0] = 0; 519 520 // "canonicalize" the locale ID to ICU/Java format 521 err = U_ZERO_ERROR; 522 length = canonicalize ? 523 uloc_canonicalize(localeID, fullName, sizeof(fullNameBuffer), &err) : 524 uloc_getName(localeID, fullName, sizeof(fullNameBuffer), &err); 525 526 if(err == U_BUFFER_OVERFLOW_ERROR || length >= (int32_t)sizeof(fullNameBuffer)) { 527 /*Go to heap for the fullName if necessary*/ 528 fullName = (char *)uprv_malloc(sizeof(char)*(length + 1)); 529 if(fullName == 0) { 530 fullName = fullNameBuffer; 531 break; // error: out of memory 532 } 533 err = U_ZERO_ERROR; 534 length = canonicalize ? 535 uloc_canonicalize(localeID, fullName, length+1, &err) : 536 uloc_getName(localeID, fullName, length+1, &err); 537 } 538 if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) { 539 /* should never occur */ 540 break; 541 } 542 543 variantBegin = length; 544 545 /* after uloc_getName/canonicalize() we know that only '_' are separators */ 546 separator = field[0] = fullName; 547 fieldIdx = 1; 548 while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR)) && fieldIdx < UPRV_LENGTHOF(field)-1) { 549 field[fieldIdx] = separator + 1; 550 fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]); 551 fieldIdx++; 552 } 553 // variant may contain @foo or .foo POSIX cruft; remove it 554 separator = uprv_strchr(field[fieldIdx-1], '@'); 555 char* sep2 = uprv_strchr(field[fieldIdx-1], '.'); 556 if (separator!=NULL || sep2!=NULL) { 557 if (separator==NULL || (sep2!=NULL && separator > sep2)) { 558 separator = sep2; 559 } 560 fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]); 561 } else { 562 fieldLen[fieldIdx-1] = length - (int32_t)(field[fieldIdx-1] - fullName); 563 } 564 565 if (fieldLen[0] >= (int32_t)(sizeof(language))) 566 { 567 break; // error: the language field is too long 568 } 569 570 variantField = 1; /* Usually the 2nd one, except when a script or country is also used. */ 571 if (fieldLen[0] > 0) { 572 /* We have a language */ 573 uprv_memcpy(language, fullName, fieldLen[0]); 574 language[fieldLen[0]] = 0; 575 } 576 if (fieldLen[1] == 4 && ISASCIIALPHA(field[1][0]) && 577 ISASCIIALPHA(field[1][1]) && ISASCIIALPHA(field[1][2]) && 578 ISASCIIALPHA(field[1][3])) { 579 /* We have at least a script */ 580 uprv_memcpy(script, field[1], fieldLen[1]); 581 script[fieldLen[1]] = 0; 582 variantField++; 583 } 584 585 if (fieldLen[variantField] == 2 || fieldLen[variantField] == 3) { 586 /* We have a country */ 587 uprv_memcpy(country, field[variantField], fieldLen[variantField]); 588 country[fieldLen[variantField]] = 0; 589 variantField++; 590 } else if (fieldLen[variantField] == 0) { 591 variantField++; /* script or country empty but variant in next field (i.e. en__POSIX) */ 592 } 593 594 if (fieldLen[variantField] > 0) { 595 /* We have a variant */ 596 variantBegin = (int32_t)(field[variantField] - fullName); 597 } 598 599 err = U_ZERO_ERROR; 600 initBaseName(err); 601 if (U_FAILURE(err)) { 602 break; 603 } 604 605 // successful end of init() 606 return *this; 607 } while(0); /*loop doesn't iterate*/ 608 609 // when an error occurs, then set this object to "bogus" (there is no UErrorCode here) 610 setToBogus(); 611 612 return *this; 613 } 614 615 /* 616 * Set up the base name. 617 * If there are no key words, it's exactly the full name. 618 * If key words exist, it's the full name truncated at the '@' character. 619 * Need to set up both at init() and after setting a keyword. 620 */ 621 void 622 Locale::initBaseName(UErrorCode &status) { 623 if (U_FAILURE(status)) { 624 return; 625 } 626 U_ASSERT(baseName==NULL || baseName==fullName); 627 const char *atPtr = uprv_strchr(fullName, '@'); 628 const char *eqPtr = uprv_strchr(fullName, '='); 629 if (atPtr && eqPtr && atPtr < eqPtr) { 630 // Key words exist. 631 int32_t baseNameLength = (int32_t)(atPtr - fullName); 632 baseName = (char *)uprv_malloc(baseNameLength + 1); 633 if (baseName == NULL) { 634 status = U_MEMORY_ALLOCATION_ERROR; 635 return; 636 } 637 uprv_strncpy(baseName, fullName, baseNameLength); 638 baseName[baseNameLength] = 0; 639 640 // The original computation of variantBegin leaves it equal to the length 641 // of fullName if there is no variant. It should instead be 642 // the length of the baseName. 643 if (variantBegin > baseNameLength) { 644 variantBegin = baseNameLength; 645 } 646 } else { 647 baseName = fullName; 648 } 649 } 650 651 652 int32_t 653 Locale::hashCode() const 654 { 655 return ustr_hashCharsN(fullName, uprv_strlen(fullName)); 656 } 657 658 void 659 Locale::setToBogus() { 660 /* Free our current storage */ 661 if(baseName != fullName) { 662 uprv_free(baseName); 663 } 664 baseName = NULL; 665 if(fullName != fullNameBuffer) { 666 uprv_free(fullName); 667 fullName = fullNameBuffer; 668 } 669 *fullNameBuffer = 0; 670 *language = 0; 671 *script = 0; 672 *country = 0; 673 fIsBogus = TRUE; 674 variantBegin = 0; 675 } 676 677 const Locale& U_EXPORT2 678 Locale::getDefault() 679 { 680 { 681 Mutex lock(&gDefaultLocaleMutex); 682 if (gDefaultLocale != NULL) { 683 return *gDefaultLocale; 684 } 685 } 686 UErrorCode status = U_ZERO_ERROR; 687 return *locale_set_default_internal(NULL, status); 688 } 689 690 691 692 void U_EXPORT2 693 Locale::setDefault( const Locale& newLocale, 694 UErrorCode& status) 695 { 696 if (U_FAILURE(status)) { 697 return; 698 } 699 700 /* Set the default from the full name string of the supplied locale. 701 * This is a convenient way to access the default locale caching mechanisms. 702 */ 703 const char *localeID = newLocale.getName(); 704 locale_set_default_internal(localeID, status); 705 } 706 707 Locale U_EXPORT2 708 Locale::createFromName (const char *name) 709 { 710 if (name) { 711 Locale l(""); 712 l.init(name, FALSE); 713 return l; 714 } 715 else { 716 return getDefault(); 717 } 718 } 719 720 Locale U_EXPORT2 721 Locale::createCanonical(const char* name) { 722 Locale loc(""); 723 loc.init(name, TRUE); 724 return loc; 725 } 726 727 const char * 728 Locale::getISO3Language() const 729 { 730 return uloc_getISO3Language(fullName); 731 } 732 733 734 const char * 735 Locale::getISO3Country() const 736 { 737 return uloc_getISO3Country(fullName); 738 } 739 740 /** 741 * Return the LCID value as specified in the "LocaleID" resource for this 742 * locale. The LocaleID must be expressed as a hexadecimal number, from 743 * one to four digits. If the LocaleID resource is not present, or is 744 * in an incorrect format, 0 is returned. The LocaleID is for use in 745 * Windows (it is an LCID), but is available on all platforms. 746 */ 747 uint32_t 748 Locale::getLCID() const 749 { 750 return uloc_getLCID(fullName); 751 } 752 753 const char* const* U_EXPORT2 Locale::getISOCountries() 754 { 755 return uloc_getISOCountries(); 756 } 757 758 const char* const* U_EXPORT2 Locale::getISOLanguages() 759 { 760 return uloc_getISOLanguages(); 761 } 762 763 // Set the locale's data based on a posix id. 764 void Locale::setFromPOSIXID(const char *posixID) 765 { 766 init(posixID, TRUE); 767 } 768 769 const Locale & U_EXPORT2 770 Locale::getRoot(void) 771 { 772 return getLocale(eROOT); 773 } 774 775 const Locale & U_EXPORT2 776 Locale::getEnglish(void) 777 { 778 return getLocale(eENGLISH); 779 } 780 781 const Locale & U_EXPORT2 782 Locale::getFrench(void) 783 { 784 return getLocale(eFRENCH); 785 } 786 787 const Locale & U_EXPORT2 788 Locale::getGerman(void) 789 { 790 return getLocale(eGERMAN); 791 } 792 793 const Locale & U_EXPORT2 794 Locale::getItalian(void) 795 { 796 return getLocale(eITALIAN); 797 } 798 799 const Locale & U_EXPORT2 800 Locale::getJapanese(void) 801 { 802 return getLocale(eJAPANESE); 803 } 804 805 const Locale & U_EXPORT2 806 Locale::getKorean(void) 807 { 808 return getLocale(eKOREAN); 809 } 810 811 const Locale & U_EXPORT2 812 Locale::getChinese(void) 813 { 814 return getLocale(eCHINESE); 815 } 816 817 const Locale & U_EXPORT2 818 Locale::getSimplifiedChinese(void) 819 { 820 return getLocale(eCHINA); 821 } 822 823 const Locale & U_EXPORT2 824 Locale::getTraditionalChinese(void) 825 { 826 return getLocale(eTAIWAN); 827 } 828 829 830 const Locale & U_EXPORT2 831 Locale::getFrance(void) 832 { 833 return getLocale(eFRANCE); 834 } 835 836 const Locale & U_EXPORT2 837 Locale::getGermany(void) 838 { 839 return getLocale(eGERMANY); 840 } 841 842 const Locale & U_EXPORT2 843 Locale::getItaly(void) 844 { 845 return getLocale(eITALY); 846 } 847 848 const Locale & U_EXPORT2 849 Locale::getJapan(void) 850 { 851 return getLocale(eJAPAN); 852 } 853 854 const Locale & U_EXPORT2 855 Locale::getKorea(void) 856 { 857 return getLocale(eKOREA); 858 } 859 860 const Locale & U_EXPORT2 861 Locale::getChina(void) 862 { 863 return getLocale(eCHINA); 864 } 865 866 const Locale & U_EXPORT2 867 Locale::getPRC(void) 868 { 869 return getLocale(eCHINA); 870 } 871 872 const Locale & U_EXPORT2 873 Locale::getTaiwan(void) 874 { 875 return getLocale(eTAIWAN); 876 } 877 878 const Locale & U_EXPORT2 879 Locale::getUK(void) 880 { 881 return getLocale(eUK); 882 } 883 884 const Locale & U_EXPORT2 885 Locale::getUS(void) 886 { 887 return getLocale(eUS); 888 } 889 890 const Locale & U_EXPORT2 891 Locale::getCanada(void) 892 { 893 return getLocale(eCANADA); 894 } 895 896 const Locale & U_EXPORT2 897 Locale::getCanadaFrench(void) 898 { 899 return getLocale(eCANADA_FRENCH); 900 } 901 902 const Locale & 903 Locale::getLocale(int locid) 904 { 905 Locale *localeCache = getLocaleCache(); 906 U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0)); 907 if (localeCache == NULL) { 908 // Failure allocating the locale cache. 909 // The best we can do is return a NULL reference. 910 locid = 0; 911 } 912 return localeCache[locid]; /*operating on NULL*/ 913 } 914 915 /* 916 This function is defined this way in order to get around static 917 initialization and static destruction. 918 */ 919 Locale * 920 Locale::getLocaleCache(void) 921 { 922 UErrorCode status = U_ZERO_ERROR; 923 umtx_initOnce(gLocaleCacheInitOnce, locale_init, status); 924 return gLocaleCache; 925 } 926 927 class KeywordEnumeration : public StringEnumeration { 928 private: 929 char *keywords; 930 char *current; 931 int32_t length; 932 UnicodeString currUSKey; 933 static const char fgClassID;/* Warning this is used beyond the typical RTTI usage. */ 934 935 public: 936 static UClassID U_EXPORT2 getStaticClassID(void) { return (UClassID)&fgClassID; } 937 virtual UClassID getDynamicClassID(void) const { return getStaticClassID(); } 938 public: 939 KeywordEnumeration(const char *keys, int32_t keywordLen, int32_t currentIndex, UErrorCode &status) 940 : keywords((char *)&fgClassID), current((char *)&fgClassID), length(0) { 941 if(U_SUCCESS(status) && keywordLen != 0) { 942 if(keys == NULL || keywordLen < 0) { 943 status = U_ILLEGAL_ARGUMENT_ERROR; 944 } else { 945 keywords = (char *)uprv_malloc(keywordLen+1); 946 if (keywords == NULL) { 947 status = U_MEMORY_ALLOCATION_ERROR; 948 } 949 else { 950 uprv_memcpy(keywords, keys, keywordLen); 951 keywords[keywordLen] = 0; 952 current = keywords + currentIndex; 953 length = keywordLen; 954 } 955 } 956 } 957 } 958 959 virtual ~KeywordEnumeration(); 960 961 virtual StringEnumeration * clone() const 962 { 963 UErrorCode status = U_ZERO_ERROR; 964 return new KeywordEnumeration(keywords, length, (int32_t)(current - keywords), status); 965 } 966 967 virtual int32_t count(UErrorCode &/*status*/) const { 968 char *kw = keywords; 969 int32_t result = 0; 970 while(*kw) { 971 result++; 972 kw += uprv_strlen(kw)+1; 973 } 974 return result; 975 } 976 977 virtual const char* next(int32_t* resultLength, UErrorCode& status) { 978 const char* result; 979 int32_t len; 980 if(U_SUCCESS(status) && *current != 0) { 981 result = current; 982 len = (int32_t)uprv_strlen(current); 983 current += len+1; 984 if(resultLength != NULL) { 985 *resultLength = len; 986 } 987 } else { 988 if(resultLength != NULL) { 989 *resultLength = 0; 990 } 991 result = NULL; 992 } 993 return result; 994 } 995 996 virtual const UnicodeString* snext(UErrorCode& status) { 997 int32_t resultLength = 0; 998 const char *s = next(&resultLength, status); 999 return setChars(s, resultLength, status); 1000 } 1001 1002 virtual void reset(UErrorCode& /*status*/) { 1003 current = keywords; 1004 } 1005 }; 1006 1007 const char KeywordEnumeration::fgClassID = '\0'; 1008 1009 KeywordEnumeration::~KeywordEnumeration() { 1010 uprv_free(keywords); 1011 } 1012 1013 StringEnumeration * 1014 Locale::createKeywords(UErrorCode &status) const 1015 { 1016 char keywords[256]; 1017 int32_t keywordCapacity = 256; 1018 StringEnumeration *result = NULL; 1019 1020 const char* variantStart = uprv_strchr(fullName, '@'); 1021 const char* assignment = uprv_strchr(fullName, '='); 1022 if(variantStart) { 1023 if(assignment > variantStart) { 1024 int32_t keyLen = locale_getKeywords(variantStart+1, '@', keywords, keywordCapacity, NULL, 0, NULL, FALSE, &status); 1025 if(keyLen) { 1026 result = new KeywordEnumeration(keywords, keyLen, 0, status); 1027 } 1028 } else { 1029 status = U_INVALID_FORMAT_ERROR; 1030 } 1031 } 1032 return result; 1033 } 1034 1035 int32_t 1036 Locale::getKeywordValue(const char* keywordName, char *buffer, int32_t bufLen, UErrorCode &status) const 1037 { 1038 return uloc_getKeywordValue(fullName, keywordName, buffer, bufLen, &status); 1039 } 1040 1041 void 1042 Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status) 1043 { 1044 uloc_setKeywordValue(keywordName, keywordValue, fullName, ULOC_FULLNAME_CAPACITY, &status); 1045 if (U_SUCCESS(status) && baseName == fullName) { 1046 // May have added the first keyword, meaning that the fullName is no longer also the baseName. 1047 initBaseName(status); 1048 } 1049 } 1050 1051 const char * 1052 Locale::getBaseName() const { 1053 return baseName; 1054 } 1055 1056 //eof 1057 U_NAMESPACE_END 1058
