diff options
Diffstat (limited to 'Build/source/libs/icu/icu-50.1/common/locid.cpp')
-rw-r--r-- | Build/source/libs/icu/icu-50.1/common/locid.cpp | 1105 |
1 files changed, 1105 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-50.1/common/locid.cpp b/Build/source/libs/icu/icu-50.1/common/locid.cpp new file mode 100644 index 00000000000..15ac812bac1 --- /dev/null +++ b/Build/source/libs/icu/icu-50.1/common/locid.cpp @@ -0,0 +1,1105 @@ +/* + ********************************************************************** + * Copyright (C) 1997-2011, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** +* +* File locid.cpp +* +* Created by: Richard Gillam +* +* Modification History: +* +* Date Name Description +* 02/11/97 aliu Changed gLocPath to fgDataDirectory and added +* methods to get and set it. +* 04/02/97 aliu Made operator!= inline; fixed return value +* of getName(). +* 04/15/97 aliu Cleanup for AIX/Win32. +* 04/24/97 aliu Numerous changes per code review. +* 08/18/98 stephen Changed getDisplayName() +* Added SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE +* Added getISOCountries(), getISOLanguages(), +* getLanguagesForCountry() +* 03/16/99 bertrand rehaul. +* 07/21/99 stephen Added U_CFUNC setDefault +* 11/09/99 weiv Added const char * getName() const; +* 04/12/00 srl removing unicodestring api's and cached hash code +* 08/10/01 grhoten Change the static Locales to accessor functions +****************************************************************************** +*/ + + +#include "unicode/locid.h" +#include "unicode/uloc.h" +#include "putilimp.h" +#include "umutex.h" +#include "uassert.h" +#include "cmemory.h" +#include "cstring.h" +#include "uhash.h" +#include "ucln_cmn.h" +#include "ustr_imp.h" + +#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) + +typedef enum ELocalePos { + eENGLISH, + eFRENCH, + eGERMAN, + eITALIAN, + eJAPANESE, + eKOREAN, + eCHINESE, + + eFRANCE, + eGERMANY, + eITALY, + eJAPAN, + eKOREA, + eCHINA, /* Alias for PRC */ + eTAIWAN, + eUK, + eUS, + eCANADA, + eCANADA_FRENCH, + eROOT, + + + //eDEFAULT, + eMAX_LOCALES +} ELocalePos; + +U_CFUNC int32_t locale_getKeywords(const char *localeID, + char prev, + char *keywords, int32_t keywordCapacity, + char *values, int32_t valuesCapacity, int32_t *valLen, + UBool valuesToo, + UErrorCode *status); + +static icu::Locale *gLocaleCache = NULL; +static icu::Locale *gDefaultLocale = NULL; +static UHashtable *gDefaultLocalesHashT = NULL; + +U_CDECL_BEGIN +// +// Deleter function for Locales owned by the default Locale hash table/ +// +static void U_CALLCONV +deleteLocale(void *obj) { + delete (icu::Locale *) obj; +} + +static UBool U_CALLCONV locale_cleanup(void) +{ + U_NAMESPACE_USE + + if (gLocaleCache) { + delete [] gLocaleCache; + gLocaleCache = NULL; + } + + if (gDefaultLocalesHashT) { + uhash_close(gDefaultLocalesHashT); // Automatically deletes all elements, using deleter func. + gDefaultLocalesHashT = NULL; + } + else if (gDefaultLocale) { + // The cache wasn't created, and only one default locale was created. + delete gDefaultLocale; + } + gDefaultLocale = NULL; + + return TRUE; +} +U_CDECL_END + +U_NAMESPACE_BEGIN +// +// locale_set_default_internal. +// +void locale_set_default_internal(const char *id) +{ + UErrorCode status = U_ZERO_ERROR; + UBool canonicalize = FALSE; + + // If given a NULL string for the locale id, grab the default + // name from the system. + // (Different from most other locale APIs, where a null name means use + // the current ICU default locale.) + if (id == NULL) { + umtx_lock(NULL); + id = uprv_getDefaultLocaleID(); + umtx_unlock(NULL); + canonicalize = TRUE; // always canonicalize host ID + } + + // put the locale id into a canonical form, + // in preparation for looking up this locale in the hash table of + // already-created locale objects. + // + status = U_ZERO_ERROR; + char localeNameBuf[512]; + + if (canonicalize) { + uloc_canonicalize(id, localeNameBuf, sizeof(localeNameBuf)-1, &status); + } else { + uloc_getName(id, localeNameBuf, sizeof(localeNameBuf)-1, &status); + } + localeNameBuf[sizeof(localeNameBuf)-1] = 0; // Force null termination in event of + // a long name filling the buffer. + // (long names are truncated.) + + // Lazy creation of the hash table itself, if needed. + UBool isOnlyLocale; + UMTX_CHECK(NULL, (gDefaultLocale == NULL), isOnlyLocale); + if (isOnlyLocale) { + // We haven't seen this locale id before. + // Create a new Locale object for it. + Locale *newFirstDefault = new Locale(Locale::eBOGUS); + if (newFirstDefault == NULL) { + // No way to report errors from here. + return; + } + newFirstDefault->init(localeNameBuf, FALSE); + umtx_lock(NULL); + if (gDefaultLocale == NULL) { + gDefaultLocale = newFirstDefault; // Assignment to gDefaultLocale must happen inside mutex + newFirstDefault = NULL; + ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); + } + // Else some other thread raced us through here, and set the new Locale. + // Use the hash table next. + umtx_unlock(NULL); + if (newFirstDefault == NULL) { + // We were successful in setting the locale, and we were the first one to set it. + return; + } + // else start using the hash table. + } + + // Lazy creation of the hash table itself, if needed. + UBool hashTableNeedsInit; + UMTX_CHECK(NULL, (gDefaultLocalesHashT == NULL), hashTableNeedsInit); + if (hashTableNeedsInit) { + status = U_ZERO_ERROR; + UHashtable *tHashTable = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status); + if (U_FAILURE(status)) { + return; + } + uhash_setValueDeleter(tHashTable, deleteLocale); + umtx_lock(NULL); + if (gDefaultLocalesHashT == NULL) { + gDefaultLocalesHashT = tHashTable; + ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); + } else { + uhash_close(tHashTable); + hashTableNeedsInit = FALSE; + } + umtx_unlock(NULL); + } + + // Hash table lookup, key is the locale full name + umtx_lock(NULL); + Locale *newDefault = (Locale *)uhash_get(gDefaultLocalesHashT, localeNameBuf); + if (newDefault != NULL) { + // We have the requested locale in the hash table already. + // Just set it as default. Inside the mutex lock, for those troublesome processors. + gDefaultLocale = newDefault; + umtx_unlock(NULL); + } else { + umtx_unlock(NULL); + // We haven't seen this locale id before. + // Create a new Locale object for it. + newDefault = new Locale(Locale::eBOGUS); + if (newDefault == NULL) { + // No way to report errors from here. + return; + } + newDefault->init(localeNameBuf, FALSE); + + // Add newly created Locale to the hash table of default Locales + const char *key = newDefault->getName(); + U_ASSERT(uprv_strcmp(key, localeNameBuf) == 0); + umtx_lock(NULL); + Locale *hashTableVal = (Locale *)uhash_get(gDefaultLocalesHashT, key); + if (hashTableVal == NULL) { + if (hashTableNeedsInit) { + // This is the second request to set the locale. + // Cache the first one. + uhash_put(gDefaultLocalesHashT, (void *)gDefaultLocale->getName(), gDefaultLocale, &status); + } + uhash_put(gDefaultLocalesHashT, (void *)key, newDefault, &status); + gDefaultLocale = newDefault; + // ignore errors from hash table insert. (Couldn't do anything anyway) + // We can still set the default Locale, + // it just wont be cached, and will eventually leak. + } else { + // Some other thread raced us through here, and got the new Locale + // into the hash table before us. Use that one. + gDefaultLocale = hashTableVal; // Assignment to gDefaultLocale must happen inside mutex + delete newDefault; + } + umtx_unlock(NULL); + } +} +U_NAMESPACE_END + +/* sfb 07/21/99 */ +U_CFUNC void +locale_set_default(const char *id) +{ + U_NAMESPACE_USE + locale_set_default_internal(id); +} +/* end */ + +U_CFUNC const char * +locale_get_default(void) +{ + U_NAMESPACE_USE + + return Locale::getDefault().getName(); +} + + +U_NAMESPACE_BEGIN + +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale) + +/*Character separating the posix id fields*/ +// '_' +// In the platform codepage. +#define SEP_CHAR '_' + +Locale::~Locale() +{ + /*if fullName is on the heap, we free it*/ + if (fullName != fullNameBuffer) + { + uprv_free(fullName); + fullName = NULL; + } + if (baseName && baseName != baseNameBuffer) { + uprv_free(baseName); + baseName = NULL; + } +} + +Locale::Locale() + : UObject(), fullName(fullNameBuffer), baseName(NULL) +{ + init(NULL, FALSE); +} + +/* + * Internal constructor to allow construction of a locale object with + * NO side effects. (Default constructor tries to get + * the default locale.) + */ +Locale::Locale(Locale::ELocaleType) + : UObject(), fullName(fullNameBuffer), baseName(NULL) +{ + setToBogus(); +} + + +Locale::Locale( const char * newLanguage, + const char * newCountry, + const char * newVariant, + const char * newKeywords) + : UObject(), fullName(fullNameBuffer), baseName(NULL) +{ + if( (newLanguage==NULL) && (newCountry == NULL) && (newVariant == NULL) ) + { + init(NULL, FALSE); /* shortcut */ + } + else + { + MaybeStackArray<char, ULOC_FULLNAME_CAPACITY> togo; + int32_t size = 0; + int32_t lsize = 0; + int32_t csize = 0; + int32_t vsize = 0; + int32_t ksize = 0; + char *p; + + // Calculate the size of the resulting string. + + // Language + if ( newLanguage != NULL ) + { + lsize = (int32_t)uprv_strlen(newLanguage); + size = lsize; + } + + // _Country + if ( newCountry != NULL ) + { + csize = (int32_t)uprv_strlen(newCountry); + size += csize; + } + + // _Variant + if ( newVariant != NULL ) + { + // remove leading _'s + while(newVariant[0] == SEP_CHAR) + { + newVariant++; + } + + // remove trailing _'s + vsize = (int32_t)uprv_strlen(newVariant); + while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) ) + { + vsize--; + } + } + + if( vsize > 0 ) + { + size += vsize; + } + + // Separator rules: + if ( vsize > 0 ) + { + size += 2; // at least: __v + } + else if ( csize > 0 ) + { + size += 1; // at least: _v + } + + if ( newKeywords != NULL) + { + ksize = (int32_t)uprv_strlen(newKeywords); + size += ksize + 1; + } + + + // NOW we have the full locale string.. + + /*if the whole string is longer than our internal limit, we need + to go to the heap for temporary buffers*/ + if (size >= togo.getCapacity()) + { + // If togo_heap could not be created, initialize with default settings. + if (togo.resize(size+1) == NULL) { + init(NULL, FALSE); + } + } + + togo[0] = 0; + + // Now, copy it back. + p = togo.getAlias(); + if ( lsize != 0 ) + { + uprv_strcpy(p, newLanguage); + p += lsize; + } + + if ( ( vsize != 0 ) || (csize != 0) ) // at least: __v + { // ^ + *p++ = SEP_CHAR; + } + + if ( csize != 0 ) + { + uprv_strcpy(p, newCountry); + p += csize; + } + + if ( vsize != 0) + { + *p++ = SEP_CHAR; // at least: __v + + uprv_strncpy(p, newVariant, vsize); // Must use strncpy because + p += vsize; // of trimming (above). + *p = 0; // terminate + } + + if ( ksize != 0) + { + if (uprv_strchr(newKeywords, '=')) { + *p++ = '@'; /* keyword parsing */ + } + else { + *p++ = '_'; /* Variant parsing with a script */ + if ( vsize == 0) { + *p++ = '_'; /* No country found */ + } + } + uprv_strcpy(p, newKeywords); + p += ksize; + } + + // Parse it, because for example 'language' might really be a complete + // string. + init(togo.getAlias(), FALSE); + } +} + +Locale::Locale(const Locale &other) + : UObject(other), fullName(fullNameBuffer), baseName(NULL) +{ + *this = other; +} + +Locale &Locale::operator=(const Locale &other) +{ + if (this == &other) { + return *this; + } + + if (&other == NULL) { + this->setToBogus(); + return *this; + } + + /* Free our current storage */ + if(fullName != fullNameBuffer) { + uprv_free(fullName); + fullName = fullNameBuffer; + } + + /* Allocate the full name if necessary */ + if(other.fullName != other.fullNameBuffer) { + fullName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(other.fullName)+1)); + if (fullName == NULL) { + return *this; + } + } + /* Copy the full name */ + uprv_strcpy(fullName, other.fullName); + + /* baseName is the cached result of getBaseName. if 'other' has a + baseName and it fits in baseNameBuffer, then copy it. otherwise set + it to NULL, and let the user lazy-create it (in getBaseName) if they + want it. */ + if(baseName && baseName != baseNameBuffer) { + uprv_free(baseName); + } + baseName = NULL; + + if(other.baseName == other.baseNameBuffer) { + uprv_strcpy(baseNameBuffer, other.baseNameBuffer); + baseName = baseNameBuffer; + } + + /* Copy the language and country fields */ + uprv_strcpy(language, other.language); + uprv_strcpy(script, other.script); + uprv_strcpy(country, other.country); + + /* The variantBegin is an offset, just copy it */ + variantBegin = other.variantBegin; + fIsBogus = other.fIsBogus; + return *this; +} + +Locale * +Locale::clone() const { + return new Locale(*this); +} + +UBool +Locale::operator==( const Locale& other) const +{ + return (uprv_strcmp(other.fullName, fullName) == 0); +} + +#define ISASCIIALPHA(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z')) + +/*This function initializes a Locale from a C locale ID*/ +Locale& Locale::init(const char* localeID, UBool canonicalize) +{ + fIsBogus = FALSE; + /* Free our current storage */ + if(fullName != fullNameBuffer) { + uprv_free(fullName); + fullName = fullNameBuffer; + } + + if(baseName && baseName != baseNameBuffer) { + uprv_free(baseName); + baseName = NULL; + } + + // not a loop: + // just an easy way to have a common error-exit + // without goto and without another function + do { + char *separator; + char *field[5] = {0}; + int32_t fieldLen[5] = {0}; + int32_t fieldIdx; + int32_t variantField; + int32_t length; + UErrorCode err; + + if(localeID == NULL) { + // not an error, just set the default locale + return *this = getDefault(); + } + + /* preset all fields to empty */ + language[0] = script[0] = country[0] = 0; + + // "canonicalize" the locale ID to ICU/Java format + err = U_ZERO_ERROR; + length = canonicalize ? + uloc_canonicalize(localeID, fullName, sizeof(fullNameBuffer), &err) : + uloc_getName(localeID, fullName, sizeof(fullNameBuffer), &err); + + if(err == U_BUFFER_OVERFLOW_ERROR || length >= (int32_t)sizeof(fullNameBuffer)) { + /*Go to heap for the fullName if necessary*/ + fullName = (char *)uprv_malloc(sizeof(char)*(length + 1)); + if(fullName == 0) { + fullName = fullNameBuffer; + break; // error: out of memory + } + err = U_ZERO_ERROR; + length = canonicalize ? + uloc_canonicalize(localeID, fullName, length+1, &err) : + uloc_getName(localeID, fullName, length+1, &err); + } + if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) { + /* should never occur */ + break; + } + + variantBegin = length; + + /* after uloc_getName/canonicalize() we know that only '_' are separators */ + separator = field[0] = fullName; + fieldIdx = 1; + while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR)) && fieldIdx < (int32_t)(sizeof(field)/sizeof(field[0]))-1) { + field[fieldIdx] = separator + 1; + fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]); + fieldIdx++; + } + // variant may contain @foo or .foo POSIX cruft; remove it + separator = uprv_strchr(field[fieldIdx-1], '@'); + char* sep2 = uprv_strchr(field[fieldIdx-1], '.'); + if (separator!=NULL || sep2!=NULL) { + if (separator==NULL || (sep2!=NULL && separator > sep2)) { + separator = sep2; + } + fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]); + } else { + fieldLen[fieldIdx-1] = length - (int32_t)(field[fieldIdx-1] - fullName); + } + + if (fieldLen[0] >= (int32_t)(sizeof(language))) + { + break; // error: the language field is too long + } + + variantField = 1; /* Usually the 2nd one, except when a script or country is also used. */ + if (fieldLen[0] > 0) { + /* We have a language */ + uprv_memcpy(language, fullName, fieldLen[0]); + language[fieldLen[0]] = 0; + } + if (fieldLen[1] == 4 && ISASCIIALPHA(field[1][0]) && + ISASCIIALPHA(field[1][1]) && ISASCIIALPHA(field[1][2]) && + ISASCIIALPHA(field[1][3])) { + /* We have at least a script */ + uprv_memcpy(script, field[1], fieldLen[1]); + script[fieldLen[1]] = 0; + variantField++; + } + + if (fieldLen[variantField] == 2 || fieldLen[variantField] == 3) { + /* We have a country */ + uprv_memcpy(country, field[variantField], fieldLen[variantField]); + country[fieldLen[variantField]] = 0; + variantField++; + } else if (fieldLen[variantField] == 0) { + variantField++; /* script or country empty but variant in next field (i.e. en__POSIX) */ + } + + if (fieldLen[variantField] > 0) { + /* We have a variant */ + variantBegin = (int32_t)(field[variantField] - fullName); + } + + // successful end of init() + return *this; + } while(0); /*loop doesn't iterate*/ + + // when an error occurs, then set this object to "bogus" (there is no UErrorCode here) + setToBogus(); + + return *this; +} + +int32_t +Locale::hashCode() const +{ + return ustr_hashCharsN(fullName, uprv_strlen(fullName)); +} + +void +Locale::setToBogus() { + /* Free our current storage */ + if(fullName != fullNameBuffer) { + uprv_free(fullName); + fullName = fullNameBuffer; + } + if(baseName && baseName != baseNameBuffer) { + uprv_free(baseName); + baseName = NULL; + } + *fullNameBuffer = 0; + *language = 0; + *script = 0; + *country = 0; + fIsBogus = TRUE; +} + +const Locale& U_EXPORT2 +Locale::getDefault() +{ + const Locale *retLocale; + UMTX_CHECK(NULL, gDefaultLocale, retLocale); + if (retLocale == NULL) { + locale_set_default_internal(NULL); + umtx_lock(NULL); + // Need a mutex in case some other thread set a new + // default inbetween when we set and when we get the new default. For + // processors with weak memory coherency, we might not otherwise see all + // of the newly created new default locale. + retLocale = gDefaultLocale; + umtx_unlock(NULL); + } + return *retLocale; +} + + + +void U_EXPORT2 +Locale::setDefault( const Locale& newLocale, + UErrorCode& status) +{ + if (U_FAILURE(status)) { + return; + } + + /* Set the default from the full name string of the supplied locale. + * This is a convenient way to access the default locale caching mechanisms. + */ + const char *localeID = newLocale.getName(); + locale_set_default_internal(localeID); +} + +Locale U_EXPORT2 +Locale::createFromName (const char *name) +{ + if (name) { + Locale l(""); + l.init(name, FALSE); + return l; + } + else { + return getDefault(); + } +} + +Locale U_EXPORT2 +Locale::createCanonical(const char* name) { + Locale loc(""); + loc.init(name, TRUE); + return loc; +} + +const char * +Locale::getISO3Language() const +{ + return uloc_getISO3Language(fullName); +} + + +const char * +Locale::getISO3Country() const +{ + return uloc_getISO3Country(fullName); +} + +/** + * Return the LCID value as specified in the "LocaleID" resource for this + * locale. The LocaleID must be expressed as a hexadecimal number, from + * one to four digits. If the LocaleID resource is not present, or is + * in an incorrect format, 0 is returned. The LocaleID is for use in + * Windows (it is an LCID), but is available on all platforms. + */ +uint32_t +Locale::getLCID() const +{ + return uloc_getLCID(fullName); +} + +const char* const* U_EXPORT2 Locale::getISOCountries() +{ + return uloc_getISOCountries(); +} + +const char* const* U_EXPORT2 Locale::getISOLanguages() +{ + return uloc_getISOLanguages(); +} + +// Set the locale's data based on a posix id. +void Locale::setFromPOSIXID(const char *posixID) +{ + init(posixID, TRUE); +} + +const Locale & U_EXPORT2 +Locale::getRoot(void) +{ + return getLocale(eROOT); +} + +const Locale & U_EXPORT2 +Locale::getEnglish(void) +{ + return getLocale(eENGLISH); +} + +const Locale & U_EXPORT2 +Locale::getFrench(void) +{ + return getLocale(eFRENCH); +} + +const Locale & U_EXPORT2 +Locale::getGerman(void) +{ + return getLocale(eGERMAN); +} + +const Locale & U_EXPORT2 +Locale::getItalian(void) +{ + return getLocale(eITALIAN); +} + +const Locale & U_EXPORT2 +Locale::getJapanese(void) +{ + return getLocale(eJAPANESE); +} + +const Locale & U_EXPORT2 +Locale::getKorean(void) +{ + return getLocale(eKOREAN); +} + +const Locale & U_EXPORT2 +Locale::getChinese(void) +{ + return getLocale(eCHINESE); +} + +const Locale & U_EXPORT2 +Locale::getSimplifiedChinese(void) +{ + return getLocale(eCHINA); +} + +const Locale & U_EXPORT2 +Locale::getTraditionalChinese(void) +{ + return getLocale(eTAIWAN); +} + + +const Locale & U_EXPORT2 +Locale::getFrance(void) +{ + return getLocale(eFRANCE); +} + +const Locale & U_EXPORT2 +Locale::getGermany(void) +{ + return getLocale(eGERMANY); +} + +const Locale & U_EXPORT2 +Locale::getItaly(void) +{ + return getLocale(eITALY); +} + +const Locale & U_EXPORT2 +Locale::getJapan(void) +{ + return getLocale(eJAPAN); +} + +const Locale & U_EXPORT2 +Locale::getKorea(void) +{ + return getLocale(eKOREA); +} + +const Locale & U_EXPORT2 +Locale::getChina(void) +{ + return getLocale(eCHINA); +} + +const Locale & U_EXPORT2 +Locale::getPRC(void) +{ + return getLocale(eCHINA); +} + +const Locale & U_EXPORT2 +Locale::getTaiwan(void) +{ + return getLocale(eTAIWAN); +} + +const Locale & U_EXPORT2 +Locale::getUK(void) +{ + return getLocale(eUK); +} + +const Locale & U_EXPORT2 +Locale::getUS(void) +{ + return getLocale(eUS); +} + +const Locale & U_EXPORT2 +Locale::getCanada(void) +{ + return getLocale(eCANADA); +} + +const Locale & U_EXPORT2 +Locale::getCanadaFrench(void) +{ + return getLocale(eCANADA_FRENCH); +} + +const Locale & +Locale::getLocale(int locid) +{ + Locale *localeCache = getLocaleCache(); + U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0)); + if (localeCache == NULL) { + // Failure allocating the locale cache. + // The best we can do is return a NULL reference. + locid = 0; + } + return localeCache[locid]; /*operating on NULL*/ +} + +/* +This function is defined this way in order to get around static +initialization and static destruction. + */ +Locale * +Locale::getLocaleCache(void) +{ + umtx_lock(NULL); + UBool needInit = (gLocaleCache == NULL); + umtx_unlock(NULL); + + if (needInit) { + Locale *tLocaleCache = new Locale[(int)eMAX_LOCALES]; + if (tLocaleCache == NULL) { + return NULL; + } + tLocaleCache[eROOT] = Locale(""); + tLocaleCache[eENGLISH] = Locale("en"); + tLocaleCache[eFRENCH] = Locale("fr"); + tLocaleCache[eGERMAN] = Locale("de"); + tLocaleCache[eITALIAN] = Locale("it"); + tLocaleCache[eJAPANESE] = Locale("ja"); + tLocaleCache[eKOREAN] = Locale("ko"); + tLocaleCache[eCHINESE] = Locale("zh"); + tLocaleCache[eFRANCE] = Locale("fr", "FR"); + tLocaleCache[eGERMANY] = Locale("de", "DE"); + tLocaleCache[eITALY] = Locale("it", "IT"); + tLocaleCache[eJAPAN] = Locale("ja", "JP"); + tLocaleCache[eKOREA] = Locale("ko", "KR"); + tLocaleCache[eCHINA] = Locale("zh", "CN"); + tLocaleCache[eTAIWAN] = Locale("zh", "TW"); + tLocaleCache[eUK] = Locale("en", "GB"); + tLocaleCache[eUS] = Locale("en", "US"); + tLocaleCache[eCANADA] = Locale("en", "CA"); + tLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA"); + + umtx_lock(NULL); + if (gLocaleCache == NULL) { + gLocaleCache = tLocaleCache; + tLocaleCache = NULL; + ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); + } + umtx_unlock(NULL); + if (tLocaleCache) { + delete [] tLocaleCache; // Fancy array delete will destruct each member. + } + } + return gLocaleCache; +} + +class KeywordEnumeration : public StringEnumeration { +private: + char *keywords; + char *current; + int32_t length; + UnicodeString currUSKey; + static const char fgClassID;/* Warning this is used beyond the typical RTTI usage. */ + +public: + static UClassID U_EXPORT2 getStaticClassID(void) { return (UClassID)&fgClassID; } + virtual UClassID getDynamicClassID(void) const { return getStaticClassID(); } +public: + KeywordEnumeration(const char *keys, int32_t keywordLen, int32_t currentIndex, UErrorCode &status) + : keywords((char *)&fgClassID), current((char *)&fgClassID), length(0) { + if(U_SUCCESS(status) && keywordLen != 0) { + if(keys == NULL || keywordLen < 0) { + status = U_ILLEGAL_ARGUMENT_ERROR; + } else { + keywords = (char *)uprv_malloc(keywordLen+1); + if (keywords == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + } + else { + uprv_memcpy(keywords, keys, keywordLen); + keywords[keywordLen] = 0; + current = keywords + currentIndex; + length = keywordLen; + } + } + } + } + + virtual ~KeywordEnumeration(); + + virtual StringEnumeration * clone() const + { + UErrorCode status = U_ZERO_ERROR; + return new KeywordEnumeration(keywords, length, (int32_t)(current - keywords), status); + } + + virtual int32_t count(UErrorCode &/*status*/) const { + char *kw = keywords; + int32_t result = 0; + while(*kw) { + result++; + kw += uprv_strlen(kw)+1; + } + return result; + } + + virtual const char* next(int32_t* resultLength, UErrorCode& status) { + const char* result; + int32_t len; + if(U_SUCCESS(status) && *current != 0) { + result = current; + len = (int32_t)uprv_strlen(current); + current += len+1; + if(resultLength != NULL) { + *resultLength = len; + } + } else { + if(resultLength != NULL) { + *resultLength = 0; + } + result = NULL; + } + return result; + } + + virtual const UnicodeString* snext(UErrorCode& status) { + int32_t resultLength = 0; + const char *s = next(&resultLength, status); + return setChars(s, resultLength, status); + } + + virtual void reset(UErrorCode& /*status*/) { + current = keywords; + } +}; + +const char KeywordEnumeration::fgClassID = '\0'; + +KeywordEnumeration::~KeywordEnumeration() { + uprv_free(keywords); +} + +StringEnumeration * +Locale::createKeywords(UErrorCode &status) const +{ + char keywords[256]; + int32_t keywordCapacity = 256; + StringEnumeration *result = NULL; + + const char* variantStart = uprv_strchr(fullName, '@'); + const char* assignment = uprv_strchr(fullName, '='); + if(variantStart) { + if(assignment > variantStart) { + int32_t keyLen = locale_getKeywords(variantStart+1, '@', keywords, keywordCapacity, NULL, 0, NULL, FALSE, &status); + if(keyLen) { + result = new KeywordEnumeration(keywords, keyLen, 0, status); + } + } else { + status = U_INVALID_FORMAT_ERROR; + } + } + return result; +} + +int32_t +Locale::getKeywordValue(const char* keywordName, char *buffer, int32_t bufLen, UErrorCode &status) const +{ + return uloc_getKeywordValue(fullName, keywordName, buffer, bufLen, &status); +} + +void +Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status) +{ + uloc_setKeywordValue(keywordName, keywordValue, fullName, ULOC_FULLNAME_CAPACITY, &status); +} + +const char * +Locale::getBaseName() const +{ + // lazy init + UErrorCode status = U_ZERO_ERROR; + // semantically const + if(baseName == 0) { + ((Locale *)this)->baseName = ((Locale *)this)->baseNameBuffer; + int32_t baseNameSize = uloc_getBaseName(fullName, baseName, ULOC_FULLNAME_CAPACITY, &status); + if(baseNameSize >= ULOC_FULLNAME_CAPACITY) { + ((Locale *)this)->baseName = (char *)uprv_malloc(sizeof(char) * baseNameSize + 1); + if (baseName == NULL) { + return baseName; + } + uloc_getBaseName(fullName, baseName, baseNameSize+1, &status); + } + baseName[baseNameSize] = 0; + + // the computation of variantBegin leaves it equal to the length + // of fullName if there is no variant. It should instead be + // the length of the baseName. Patch around this for now. + if (variantBegin == (int32_t)uprv_strlen(fullName)) { + ((Locale*)this)->variantBegin = baseNameSize; + } + } + return baseName; +} + +//eof +U_NAMESPACE_END |