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