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