/*
**********************************************************************
- * Copyright (C) 1997-2003, International Business Machines
+ * Copyright (C) 1997-2015, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
*
* Modification History:
*
* Date Name Description
-* 02/11/97 aliu Changed gLocPath to fgDataDirectory and added
+* 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
+* 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.
#include "unicode/locid.h"
#include "unicode/uloc.h"
+#include "putilimp.h"
+#include "mutex.h"
#include "umutex.h"
#include "uassert.h"
#include "cmemory.h"
#include "cstring.h"
+#include "uassert.h"
#include "uhash.h"
#include "ucln_cmn.h"
+#include "ustr_imp.h"
+
+U_CDECL_BEGIN
+static UBool U_CALLCONV locale_cleanup(void);
+U_CDECL_END
+
+U_NAMESPACE_BEGIN
+
+static Locale *gLocaleCache = NULL;
+static UInitOnce gLocaleCacheInitOnce = U_INITONCE_INITIALIZER;
+
+// gDefaultLocaleMutex protects all access to gDefaultLocalesHashT and gDefaultLocale.
+static UMutex gDefaultLocaleMutex = U_MUTEX_INITIALIZER;
+static UHashtable *gDefaultLocalesHashT = NULL;
+static Locale *gDefaultLocale = NULL;
+
+U_NAMESPACE_END
-static Locale* availableLocaleList = NULL;
-static int32_t availableLocaleListCount;
typedef enum ELocalePos {
eENGLISH,
eFRENCH,
eUS,
eCANADA,
eCANADA_FRENCH,
+ eROOT,
//eDEFAULT,
eMAX_LOCALES
} ELocalePos;
-/* Use void * to make it properly aligned */
-/* Add 1 for rounding */
-// static void *gByteLocaleCache[(eMAX_LOCALES + 1) * sizeof(Locale) / sizeof(void*)];
-
-static Locale *gLocaleCache = NULL;
-static Locale *gDefaultLocale = NULL;
+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);
+
+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;
+}
-UBool
-locale_cleanup(void)
+static UBool U_CALLCONV locale_cleanup(void)
{
U_NAMESPACE_USE
- if (availableLocaleList) {
- delete []availableLocaleList;
- availableLocaleList = NULL;
- }
- availableLocaleListCount = 0;
+ delete [] gLocaleCache;
+ gLocaleCache = NULL;
+ gLocaleCacheInitOnce.reset();
- if (gLocaleCache) {
- delete [] gLocaleCache;
- gLocaleCache = NULL;
- }
- if (gDefaultLocale) {
- delete gDefaultLocale;
- gDefaultLocale = NULL;
+ if (gDefaultLocalesHashT) {
+ uhash_close(gDefaultLocalesHashT); // Automatically deletes all elements, using deleter func.
+ gDefaultLocalesHashT = NULL;
}
+ gDefaultLocale = NULL;
return TRUE;
}
-U_NAMESPACE_BEGIN
-const char Locale::fgClassID=0;
-void locale_set_default_internal(const char *id)
-{
+static void U_CALLCONV locale_init(UErrorCode &status) {
U_NAMESPACE_USE
- Locale tempLocale(Locale::eBOGUS);
- if (id == NULL)
- {
- umtx_lock(NULL);
- id = uprv_getDefaultLocaleID();
- umtx_unlock(NULL);
+ U_ASSERT(gLocaleCache == NULL);
+ gLocaleCache = new Locale[(int)eMAX_LOCALES];
+ if (gLocaleCache == NULL) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
+ gLocaleCache[eROOT] = Locale("");
+ gLocaleCache[eENGLISH] = Locale("en");
+ gLocaleCache[eFRENCH] = Locale("fr");
+ gLocaleCache[eGERMAN] = Locale("de");
+ gLocaleCache[eITALIAN] = Locale("it");
+ gLocaleCache[eJAPANESE] = Locale("ja");
+ gLocaleCache[eKOREAN] = Locale("ko");
+ gLocaleCache[eCHINESE] = Locale("zh");
+ gLocaleCache[eFRANCE] = Locale("fr", "FR");
+ gLocaleCache[eGERMANY] = Locale("de", "DE");
+ gLocaleCache[eITALY] = Locale("it", "IT");
+ gLocaleCache[eJAPAN] = Locale("ja", "JP");
+ gLocaleCache[eKOREA] = Locale("ko", "KR");
+ gLocaleCache[eCHINA] = Locale("zh", "CN");
+ gLocaleCache[eTAIWAN] = Locale("zh", "TW");
+ gLocaleCache[eUK] = Locale("en", "GB");
+ gLocaleCache[eUS] = Locale("en", "US");
+ gLocaleCache[eCANADA] = Locale("en", "CA");
+ gLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA");
+}
+
+U_CDECL_END
+
+U_NAMESPACE_BEGIN
+
+Locale *locale_set_default_internal(const char *id, UErrorCode& status) {
+ // Synchronize this entire function.
+ Mutex lock(&gDefaultLocaleMutex);
+
+ 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) {
+ id = uprv_getDefaultLocaleID(); // This function not thread safe? TODO: verify.
+ canonicalize = TRUE; // always canonicalize host ID
}
- tempLocale.init(id); // Note: we do not want to hold the mutex through init(),
- // which is a relatively large, complex function.
- // Hence, the use of a temporary locale.
- const Locale *defLocale = &Locale::getDefault();
-
- umtx_lock(NULL);
- Locale *ncDefLocale = (Locale *)defLocale;
- *ncDefLocale = tempLocale;
- umtx_unlock(NULL);
+ 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.)
+ //
+ if (U_FAILURE(status)) {
+ return gDefaultLocale;
+ }
+
+ if (gDefaultLocalesHashT == NULL) {
+ gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
+ if (U_FAILURE(status)) {
+ return gDefaultLocale;
+ }
+ uhash_setValueDeleter(gDefaultLocalesHashT, deleteLocale);
+ ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
+ }
+
+ Locale *newDefault = (Locale *)uhash_get(gDefaultLocalesHashT, localeNameBuf);
+ if (newDefault == NULL) {
+ newDefault = new Locale(Locale::eBOGUS);
+ if (newDefault == NULL) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return gDefaultLocale;
+ }
+ newDefault->init(localeNameBuf, FALSE);
+ uhash_put(gDefaultLocalesHashT, (char*) newDefault->getName(), newDefault, &status);
+ if (U_FAILURE(status)) {
+ return gDefaultLocale;
+ }
+ }
+ gDefaultLocale = newDefault;
+ return gDefaultLocale;
}
+
U_NAMESPACE_END
/* sfb 07/21/99 */
locale_set_default(const char *id)
{
U_NAMESPACE_USE
- locale_set_default_internal(id);
+ UErrorCode status = U_ZERO_ERROR;
+ locale_set_default_internal(id, status);
}
/* end */
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 (baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
/*if fullName is on the heap, we free it*/
- if (fullName != fullNameBuffer)
+ if (fullName != fullNameBuffer)
{
uprv_free(fullName);
fullName = NULL;
}
Locale::Locale()
- : UObject(), fullName(fullNameBuffer)
+ : UObject(), fullName(fullNameBuffer), baseName(NULL)
{
- init(NULL);
+ init(NULL, FALSE);
}
-Locale::Locale(Locale::ELocaleType t)
- : UObject(), fullName(fullNameBuffer)
+/*
+ * 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)
- : UObject(), fullName(fullNameBuffer)
+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); /* shortcut */
+ init(NULL, FALSE); /* shortcut */
}
else
{
- char togo_stack[ULOC_FULLNAME_CAPACITY];
- char *togo;
- char *togo_heap = NULL;
+ 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.
{
newVariant++;
}
-
+
// remove trailing _'s
vsize = (int32_t)uprv_strlen(newVariant);
while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) )
// Separator rules:
if ( vsize > 0 )
{
- size += 2; // at least: __v
+ size += 2; // at least: __v
}
else if ( csize > 0 )
{
- size += 1; // at least: _v
+ 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 > ULOC_FULLNAME_CAPACITY)
- {
- togo_heap = (char *)uprv_malloc(sizeof(char)*(size+1));
- togo = togo_heap;
- }
- else
+ if (size >= togo.getCapacity())
{
- togo = togo_stack;
+ // 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;
+ p = togo.getAlias();
if ( lsize != 0 )
{
uprv_strcpy(p, newLanguage);
}
if ( csize != 0 )
- {
+ {
uprv_strcpy(p, newCountry);
p += csize;
}
{
*p++ = SEP_CHAR; // at least: __v
- uprv_strncpy(p, newVariant, vsize); // Must use strncpy because
+ 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);
-
- if (togo_heap) {
- uprv_free(togo_heap);
- }
+ init(togo.getAlias(), FALSE);
}
}
Locale::Locale(const Locale &other)
- : UObject(other), fullName(fullNameBuffer)
+ : UObject(other), fullName(fullNameBuffer), baseName(NULL)
{
*this = other;
}
return *this;
}
- if (&other == NULL) {
- this->setToBogus();
- return *this;
- }
-
/* Free our current storage */
+ if (baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
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);
+ /* Copy the baseName if it differs from fullName. */
+ if (other.baseName == other.fullName) {
+ baseName = fullName;
+ } else {
+ if (other.baseName) {
+ baseName = uprv_strdup(other.baseName);
+ }
+ }
+
/* 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 into fullName, just copy it */
+ /* 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)
+Locale& Locale::init(const char* localeID, UBool canonicalize)
{
fIsBogus = FALSE;
/* Free our current storage */
+ if (baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
if(fullName != fullNameBuffer) {
uprv_free(fullName);
fullName = fullNameBuffer;
// just an easy way to have a common error-exit
// without goto and without another function
do {
- char *separator, *prev;
+ char *separator;
+ char *field[5] = {0};
+ int32_t fieldLen[5] = {0};
+ int32_t fieldIdx;
+ int32_t variantField;
int32_t length;
UErrorCode err;
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 = uloc_getName(localeID, fullName, sizeof(fullNameBuffer), &err);
- if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) {
+ 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) {
break; // error: out of memory
}
err = U_ZERO_ERROR;
- length = uloc_getName(localeID, fullName, length + 1, &err);
+ 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;
}
- /* preset all fields to empty */
- language[0] = country[0] = 0;
- variantBegin = (int32_t)uprv_strlen(fullName);
-
- /* after uloc_getName() we know that only '_' are separators */
- separator = uprv_strchr(fullName, SEP_CHAR);
- if(separator != 0) {
- /* there is a country field */
- length = (int32_t)(separator - fullName);
- if(length > 0) {
- if(length >= (int32_t)sizeof(language)) {
- break; // error: language code too long
- }
- uprv_memcpy(language, fullName, length);
- }
- language[length] = 0;
-
- prev = separator + 1;
- separator = uprv_strchr(prev, SEP_CHAR);
- if(separator != 0) {
- /* there is a variant field */
- length = (int32_t)(separator - prev);
- if(length > 0) {
- if(length >= (int32_t)sizeof(country)) {
- break; // error: country code too long
- }
- uprv_memcpy(country, prev, length);
- }
- country[length] = 0;
+ variantBegin = length;
- variantBegin = (int32_t)((separator + 1) - fullName);
- } else {
- /* variantBegin==strlen(fullName), length==strlen(language)==prev-1-fullName */
- if((variantBegin - length - 1) >= (int32_t)sizeof(country)) {
- break; // error: country code too long
- }
- uprv_strcpy(country, prev);
+ /* 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 {
- /* variantBegin==strlen(fullName) */
- if(variantBegin >= (int32_t)sizeof(language)) {
- break; // error: language code too long
- }
- uprv_strcpy(language, fullName);
+ 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);
+ }
+
+ err = U_ZERO_ERROR;
+ initBaseName(err);
+ if (U_FAILURE(err)) {
+ break;
}
// successful end of init()
return *this;
- } while(0);
+ } while(0); /*loop doesn't iterate*/
// when an error occurs, then set this object to "bogus" (there is no UErrorCode here)
setToBogus();
return *this;
}
+/*
+ * Set up the base name.
+ * If there are no key words, it's exactly the full name.
+ * If key words exist, it's the full name truncated at the '@' character.
+ * Need to set up both at init() and after setting a keyword.
+ */
+void
+Locale::initBaseName(UErrorCode &status) {
+ if (U_FAILURE(status)) {
+ return;
+ }
+ U_ASSERT(baseName==NULL || baseName==fullName);
+ const char *atPtr = uprv_strchr(fullName, '@');
+ const char *eqPtr = uprv_strchr(fullName, '=');
+ if (atPtr && eqPtr && atPtr < eqPtr) {
+ // Key words exist.
+ int32_t baseNameLength = (int32_t)(atPtr - fullName);
+ baseName = (char *)uprv_malloc(baseNameLength + 1);
+ if (baseName == NULL) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ uprv_strncpy(baseName, fullName, baseNameLength);
+ baseName[baseNameLength] = 0;
+
+ // The original 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.
+ if (variantBegin > baseNameLength) {
+ variantBegin = baseNameLength;
+ }
+ } else {
+ baseName = fullName;
+ }
+}
+
+
int32_t
-Locale::hashCode() const
+Locale::hashCode() const
{
- UHashTok hashKey;
- hashKey.pointer = fullName;
- return uhash_hashChars(hashKey);
+ return ustr_hashCharsN(fullName, uprv_strlen(fullName));
}
-void
+void
Locale::setToBogus() {
- /* Free our current storage */
- if(fullName != fullNameBuffer) {
- uprv_free(fullName);
- fullName = fullNameBuffer;
- }
- *fullNameBuffer = 0;
- *language = 0;
- *country = 0;
- fIsBogus = TRUE;
-}
-
-const Locale&
-Locale::getDefault()
-{
- umtx_lock(NULL);
- UBool needInit = (gDefaultLocale == NULL);
- umtx_unlock(NULL);
- if (needInit) {
- Locale *tLocale = new Locale(Locale::eBOGUS);
- if (tLocale != NULL) {
- const char *cLocale;
-
- umtx_lock(NULL);
- /* uprv_getDefaultLocaleID is not thread safe, so we surround it with a mutex */
- cLocale = uprv_getDefaultLocaleID();
- umtx_unlock(NULL);
-
- tLocale->init(cLocale);
- umtx_lock(NULL);
- if (gDefaultLocale == NULL) {
- gDefaultLocale = tLocale;
- tLocale = NULL;
- }
- umtx_unlock(NULL);
- delete tLocale;
+ /* Free our current storage */
+ if(baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
+ if(fullName != fullNameBuffer) {
+ uprv_free(fullName);
+ fullName = fullNameBuffer;
+ }
+ *fullNameBuffer = 0;
+ *language = 0;
+ *script = 0;
+ *country = 0;
+ fIsBogus = TRUE;
+}
+
+const Locale& U_EXPORT2
+Locale::getDefault()
+{
+ {
+ Mutex lock(&gDefaultLocaleMutex);
+ if (gDefaultLocale != NULL) {
+ return *gDefaultLocale;
}
}
- return *gDefaultLocale;
+ UErrorCode status = U_ZERO_ERROR;
+ return *locale_set_default_internal(NULL, status);
}
-void
-Locale::setDefault( const Locale& newLocale,
- UErrorCode& status)
+
+
+void U_EXPORT2
+Locale::setDefault( const Locale& newLocale,
+ UErrorCode& status)
{
- if (U_FAILURE(status))
+ if (U_FAILURE(status)) {
return;
-
- const Locale *defLocale = &Locale::getDefault();
- umtx_lock(NULL);
- Locale *ncDefLocale = (Locale *)defLocale;
- *ncDefLocale = newLocale;
- umtx_unlock(NULL);
+ }
+
+ /* 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, status);
}
-Locale
+Locale U_EXPORT2
Locale::createFromName (const char *name)
{
if (name) {
- Locale l;
- l.init(name);
+ Locale l("");
+ l.init(name, FALSE);
return l;
}
else {
}
}
+Locale U_EXPORT2
+Locale::createCanonical(const char* name) {
+ Locale loc("");
+ loc.init(name, TRUE);
+ return loc;
+}
const char *
Locale::getISO3Language() const
* 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
+uint32_t
Locale::getLCID() const
{
return uloc_getLCID(fullName);
}
-UnicodeString&
-Locale::getDisplayLanguage(UnicodeString& dispLang) const
-{
- return this->getDisplayLanguage(getDefault(), dispLang);
-}
-
-/*We cannot make any assumptions on the size of the output display strings
-* Yet, since we are calling through to a C API, we need to set limits on
-* buffer size. For all the following getDisplay functions we first attempt
-* to fill up a stack allocated buffer. If it is to small we heap allocated
-* the exact buffer we need copy it to the UnicodeString and delete it*/
-
-UnicodeString&
-Locale::getDisplayLanguage(const Locale &displayLocale,
- UnicodeString &result) const {
- UChar *buffer;
- UErrorCode errorCode=U_ZERO_ERROR;
- int32_t length;
-
- buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
-
- length=uloc_getDisplayLanguage(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
-
- if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
- buffer=result.getBuffer(length);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
- errorCode=U_ZERO_ERROR;
- length=uloc_getDisplayLanguage(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
- }
-
- if(U_FAILURE(errorCode)) {
- result.truncate(0);
- }
-
- return result;
-}
-
-UnicodeString&
-Locale::getDisplayCountry(UnicodeString& dispCntry) const
-{
- return this->getDisplayCountry(getDefault(), dispCntry);
-}
-
-UnicodeString&
-Locale::getDisplayCountry(const Locale &displayLocale,
- UnicodeString &result) const {
- UChar *buffer;
- UErrorCode errorCode=U_ZERO_ERROR;
- int32_t length;
-
- buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
-
- length=uloc_getDisplayCountry(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
-
- if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
- buffer=result.getBuffer(length);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
- errorCode=U_ZERO_ERROR;
- length=uloc_getDisplayCountry(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
- }
-
- if(U_FAILURE(errorCode)) {
- result.truncate(0);
- }
-
- return result;
-}
-
-UnicodeString&
-Locale::getDisplayVariant(UnicodeString& dispVar) const
-{
- return this->getDisplayVariant(getDefault(), dispVar);
-}
-
-UnicodeString&
-Locale::getDisplayVariant(const Locale &displayLocale,
- UnicodeString &result) const {
- UChar *buffer;
- UErrorCode errorCode=U_ZERO_ERROR;
- int32_t length;
-
- buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
-
- length=uloc_getDisplayVariant(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
-
- if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
- buffer=result.getBuffer(length);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
- errorCode=U_ZERO_ERROR;
- length=uloc_getDisplayVariant(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
- }
-
- if(U_FAILURE(errorCode)) {
- result.truncate(0);
- }
-
- return result;
-}
-
-UnicodeString&
-Locale::getDisplayName( UnicodeString& name ) const
-{
- return this->getDisplayName(getDefault(), name);
-}
-
-UnicodeString&
-Locale::getDisplayName(const Locale &displayLocale,
- UnicodeString &result) const {
- UChar *buffer;
- UErrorCode errorCode=U_ZERO_ERROR;
- int32_t length;
-
- buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
-
- length=uloc_getDisplayName(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
-
- if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
- buffer=result.getBuffer(length);
- if(buffer==0) {
- result.truncate(0);
- return result;
- }
- errorCode=U_ZERO_ERROR;
- length=uloc_getDisplayName(fullName, displayLocale.fullName,
- buffer, result.getCapacity(),
- &errorCode);
- result.releaseBuffer(length);
- }
-
- if(U_FAILURE(errorCode)) {
- result.truncate(0);
- }
-
- return result;
-}
-const Locale*
-Locale::getAvailableLocales(int32_t& count)
-{
- // for now, there is a hardcoded list, so just walk through that list and set it up.
- umtx_lock(NULL);
- UBool needInit = availableLocaleList == 0;
- umtx_unlock(NULL);
-
- if (needInit) {
- int32_t locCount = uloc_countAvailable();
- Locale *newLocaleList = 0;
- if(locCount) {
- newLocaleList = new Locale[locCount];
- }
- if (newLocaleList == NULL) {
- return NULL;
- }
-
- count = locCount;
-
- while(--locCount >= 0) {
- newLocaleList[locCount].setFromPOSIXID(uloc_getAvailable(locCount));
- }
-
- umtx_lock(NULL);
- if(availableLocaleList == 0) {
- availableLocaleListCount = count;
- availableLocaleList = newLocaleList;
- newLocaleList = NULL;
- }
- umtx_unlock(NULL);
- delete []newLocaleList;
- }
- count = availableLocaleListCount;
- return availableLocaleList;
-}
-
-const char* const* Locale::getISOCountries()
+const char* const* U_EXPORT2 Locale::getISOCountries()
{
return uloc_getISOCountries();
}
-const char* const* Locale::getISOLanguages()
+const char* const* U_EXPORT2 Locale::getISOLanguages()
{
return uloc_getISOLanguages();
}
-// Set the locale's data based on a posix id.
+// Set the locale's data based on a posix id.
void Locale::setFromPOSIXID(const char *posixID)
{
- init(posixID);
+ init(posixID, TRUE);
}
-const Locale &
+const Locale & U_EXPORT2
+Locale::getRoot(void)
+{
+ return getLocale(eROOT);
+}
+
+const Locale & U_EXPORT2
Locale::getEnglish(void)
{
return getLocale(eENGLISH);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getFrench(void)
{
return getLocale(eFRENCH);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getGerman(void)
{
return getLocale(eGERMAN);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getItalian(void)
{
return getLocale(eITALIAN);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getJapanese(void)
{
return getLocale(eJAPANESE);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getKorean(void)
{
return getLocale(eKOREAN);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getChinese(void)
{
return getLocale(eCHINESE);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getSimplifiedChinese(void)
{
return getLocale(eCHINA);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getTraditionalChinese(void)
{
return getLocale(eTAIWAN);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getFrance(void)
{
return getLocale(eFRANCE);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getGermany(void)
{
return getLocale(eGERMANY);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getItaly(void)
{
return getLocale(eITALY);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getJapan(void)
{
return getLocale(eJAPAN);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getKorea(void)
{
return getLocale(eKOREA);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getChina(void)
{
return getLocale(eCHINA);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getPRC(void)
{
return getLocale(eCHINA);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getTaiwan(void)
{
return getLocale(eTAIWAN);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getUK(void)
{
return getLocale(eUK);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getUS(void)
{
return getLocale(eUS);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getCanada(void)
{
return getLocale(eCANADA);
}
-const Locale &
+const Locale & U_EXPORT2
Locale::getCanadaFrench(void)
{
return getLocale(eCANADA_FRENCH);
Locale::getLocale(int locid)
{
Locale *localeCache = getLocaleCache();
- U_ASSERT(locid < eMAX_LOCALES);
+ 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];
+ return localeCache[locid]; /*operating on NULL*/
}
/*
Locale *
Locale::getLocaleCache(void)
{
- umtx_lock(NULL);
- UBool needInit = (gLocaleCache == NULL);
- umtx_unlock(NULL);
-
- if (needInit) {
- Locale *tLocaleCache = new Locale[eMAX_LOCALES];
- if (tLocaleCache == NULL) {
- return NULL;
- }
- 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;
- }
- umtx_unlock(NULL);
- if (tLocaleCache) {
- delete [] tLocaleCache; // Fancy array delete will destruct each member.
+ UErrorCode status = U_ZERO_ERROR;
+ umtx_initOnce(gLocaleCacheInitOnce, locale_init, status);
+ 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;
+ }
+ }
}
}
- return gLocaleCache;
+
+ 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);
+ if (U_SUCCESS(status) && baseName == fullName) {
+ // May have added the first keyword, meaning that the fullName is no longer also the baseName.
+ initBaseName(status);
+ }
+}
+
+const char *
+Locale::getBaseName() const {
+ return baseName;
}
//eof
projects / apple / icu.git / blobdiff