+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
- * Copyright (C) 1997-2012, International Business Machines
+ * Copyright (C) 1997-2016, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
*
#include "unicode/locid.h"
+#include "unicode/strenum.h"
#include "unicode/uloc.h"
#include "putilimp.h"
#include "mutex.h"
#include "uassert.h"
#include "cmemory.h"
#include "cstring.h"
+#include "uassert.h"
#include "uhash.h"
#include "ucln_cmn.h"
#include "ustr_imp.h"
-
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+#include "charstr.h"
U_CDECL_BEGIN
static UBool U_CALLCONV locale_cleanup(void);
U_NAMESPACE_BEGIN
-static Locale *gLocaleCache = NULL;
+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;
+/**
+ * \def ULOC_STRING_LIMIT
+ * strings beyond this value crash in CharString
+ */
+#define ULOC_STRING_LIMIT 357913941
+
U_NAMESPACE_END
typedef enum ELocalePos {
{
U_NAMESPACE_USE
- if (gLocaleCache) {
- delete [] gLocaleCache;
- gLocaleCache = NULL;
- }
+ delete [] gLocaleCache;
+ gLocaleCache = NULL;
+ gLocaleCacheInitOnce.reset();
if (gDefaultLocalesHashT) {
uhash_close(gDefaultLocalesHashT); // Automatically deletes all elements, using deleter func.
gDefaultLocalesHashT = NULL;
- gDefaultLocale = NULL;
}
-
+ gDefaultLocale = NULL;
return TRUE;
}
+
+
+static void U_CALLCONV locale_init(UErrorCode &status) {
+ U_NAMESPACE_USE
+
+ 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
Locale::~Locale()
{
+ if (baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
/*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()
}
else
{
- MaybeStackArray<char, ULOC_FULLNAME_CAPACITY> togo;
+ UErrorCode status = U_ZERO_ERROR;
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.
if ( newLanguage != NULL )
{
lsize = (int32_t)uprv_strlen(newLanguage);
+ if ( lsize < 0 || lsize > ULOC_STRING_LIMIT ) { // int32 wrap
+ setToBogus();
+ return;
+ }
size = lsize;
}
+ CharString togo(newLanguage, lsize, status); // start with newLanguage
+
// _Country
if ( newCountry != NULL )
{
csize = (int32_t)uprv_strlen(newCountry);
+ if ( csize < 0 || csize > ULOC_STRING_LIMIT ) { // int32 wrap
+ setToBogus();
+ return;
+ }
size += csize;
}
// remove trailing _'s
vsize = (int32_t)uprv_strlen(newVariant);
+ if ( vsize < 0 || vsize > ULOC_STRING_LIMIT ) { // int32 wrap
+ setToBogus();
+ return;
+ }
while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) )
{
vsize--;
if ( newKeywords != NULL)
{
ksize = (int32_t)uprv_strlen(newKeywords);
+ if ( ksize < 0 || ksize > ULOC_STRING_LIMIT ) {
+ setToBogus();
+ return;
+ }
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;
- }
+
+ // newLanguage is already copied
if ( ( vsize != 0 ) || (csize != 0) ) // at least: __v
{ // ^
- *p++ = SEP_CHAR;
+ togo.append(SEP_CHAR, status);
}
if ( csize != 0 )
{
- uprv_strcpy(p, newCountry);
- p += csize;
+ togo.append(newCountry, status);
}
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
+ togo.append(SEP_CHAR, status)
+ .append(newVariant, vsize, status);
}
if ( ksize != 0)
{
if (uprv_strchr(newKeywords, '=')) {
- *p++ = '@'; /* keyword parsing */
+ togo.append('@', status); /* keyword parsing */
}
else {
- *p++ = '_'; /* Variant parsing with a script */
+ togo.append('_', status); /* Variant parsing with a script */
if ( vsize == 0) {
- *p++ = '_'; /* No country found */
+ togo.append('_', status); /* No country found */
}
}
- uprv_strcpy(p, newKeywords);
- p += ksize;
+ togo.append(newKeywords, status);
}
+ if (U_FAILURE(status)) {
+ // Something went wrong with appending, etc.
+ setToBogus();
+ return;
+ }
// Parse it, because for example 'language' might really be a complete
// string.
- init(togo.getAlias(), FALSE);
+ init(togo.data(), FALSE);
}
}
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;
/* 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 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 */
{
fIsBogus = FALSE;
/* Free our current storage */
+ if (baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
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
/* 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) {
+ while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR)) && fieldIdx < UPRV_LENGTHOF(field)-1) {
field[fieldIdx] = separator + 1;
fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]);
fieldIdx++;
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); /*loop doesn't iterate*/
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
{
void
Locale::setToBogus() {
/* Free our current storage */
+ if(baseName != fullName) {
+ uprv_free(baseName);
+ }
+ baseName = NULL;
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;
+ variantBegin = 0;
}
const Locale& U_EXPORT2
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.
- }
- }
+ UErrorCode status = U_ZERO_ERROR;
+ umtx_initOnce(gLocaleCacheInitOnce, locale_init, status);
return gLocaleCache;
}
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
-{
- // 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;
- }
- }
+Locale::getBaseName() const {
return baseName;
}
projects / apple / icu.git / blobdiff