ICU-59173.0.1.tar.gz

[apple/icu.git] / icuSources / common / locid.cpp

diff --git a/icuSources/common/locid.cpp b/icuSources/common/locid.cpp
index 80b8a32bb5f3ff2c0fba87cb93830937d20c524e..36508acaf5ca70c2fadba2fe1b5f6f0078dc5f97 100644 (file)
--- a/icuSources/common/locid.cpp
+++ b/icuSources/common/locid.cpp
@@ -1,6 +1,8 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /*
  **********************************************************************
 /*
  **********************************************************************

- *   Copyright (C) 1997-2011, International Business Machines
+ *   Copyright (C) 1997-2016, International Business Machines

  *   Corporation and others.  All Rights Reserved.
  **********************************************************************
 *
  *   Corporation and others.  All Rights Reserved.
  **********************************************************************
 *


@@ -31,17 +33,41 @@
 
 
 #include "unicode/locid.h"
 
 
 #include "unicode/locid.h"

+#include "unicode/strenum.h"

 #include "unicode/uloc.h"
 #include "putilimp.h"
 #include "unicode/uloc.h"
 #include "putilimp.h"

+#include "mutex.h"

 #include "umutex.h"
 #include "uassert.h"
 #include "cmemory.h"
 #include "cstring.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"
 #include "uhash.h"
 #include "ucln_cmn.h"
 #include "ustr_imp.h"

+#include "charstr.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;

 
 

-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+/**
+ * \def ULOC_STRING_LIMIT
+ * strings beyond this value crash in CharString
+ */
+#define ULOC_STRING_LIMIT 357913941
+
+U_NAMESPACE_END

 
 typedef enum ELocalePos {
     eENGLISH,
 
 typedef enum ELocalePos {
     eENGLISH,


@@ -77,10 +103,6 @@ U_CFUNC int32_t locale_getKeywords(const char *localeID,
             UBool valuesToo,
             UErrorCode *status);
 
             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/
 U_CDECL_BEGIN
 //
 // Deleter function for Locales owned by the default Locale hash table/


@@ -94,32 +116,58 @@ static UBool U_CALLCONV locale_cleanup(void)
 {
     U_NAMESPACE_USE
 
 {
     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;
     }
 
     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;
     gDefaultLocale = NULL;

-

     return TRUE;
 }
     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
 U_CDECL_END
 
 U_NAMESPACE_BEGIN

-//
-//  locale_set_default_internal.
-//
-void locale_set_default_internal(const char *id)
-{
-    UErrorCode   status = U_ZERO_ERROR;
+
+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
     UBool canonicalize = FALSE;
 
     // If given a NULL string for the locale id, grab the default


@@ -127,17 +175,10 @@ void locale_set_default_internal(const char *id)
     //   (Different from most other locale APIs, where a null name means use
     //    the current ICU default locale.)
     if (id == NULL) {
     //   (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);
+        id = uprv_getDefaultLocaleID();   // This function not thread safe? TODO: verify.

         canonicalize = TRUE; // always canonicalize host ID
     }
 
         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) {
     char localeNameBuf[512];
 
     if (canonicalize) {


@@ -148,110 +189,37 @@ void locale_set_default_internal(const char *id)
     localeNameBuf[sizeof(localeNameBuf)-1] = 0;  // Force null termination in event of
                                                  //   a long name filling the buffer.
                                                  //   (long names are truncated.)
     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);
-
-            // We were successful in setting the locale, and we were the first one to set it.
-            umtx_unlock(NULL);
-            return;
-        }
-        // Else some other thread raced us through here, and set the new Locale.
-        else {
-            delete newFirstDefault;
-        }
-        umtx_unlock(NULL);
-    }
-
-    // Create the hash table next, unless the racing thread is setting the same locale as default.
-    // The new locale might have been set while a racing thread was stuck at the lock
-    // earlier in this function.  (For example, see uprv_getDefaultLocaleID above).
-    umtx_lock(NULL);
-    // Only create the hash table if we need to.
-    if (uprv_strcmp(gDefaultLocale->getName(), localeNameBuf) == 0) {
-        umtx_unlock(NULL);
-        return;
+                                                 //
+    if (U_FAILURE(status)) {
+        return gDefaultLocale;

     }
     }

-    umtx_unlock(NULL);
-    // 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 (gDefaultLocalesHashT == NULL) {
+        gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);

         if (U_FAILURE(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);
-
-            uhash_put(gDefaultLocalesHashT, (void *)gDefaultLocale->getName(), gDefaultLocale, &status);
-        } else {
-            uhash_close(tHashTable);
+            return gDefaultLocale;

         }
         }

-        umtx_unlock(NULL);
+        uhash_setValueDeleter(gDefaultLocalesHashT, deleteLocale);
+        ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);

     }
 
     }
 

-    // Hash table lookup, key is the locale full name
-    umtx_lock(NULL);

     Locale *newDefault = (Locale *)uhash_get(gDefaultLocalesHashT, localeNameBuf);
     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.
+    if (newDefault == NULL) {

         newDefault = new Locale(Locale::eBOGUS);
         if (newDefault == NULL) {
         newDefault = new Locale(Locale::eBOGUS);
         if (newDefault == NULL) {

-            // No way to report errors from here.
-            return;
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return gDefaultLocale;

         }
         newDefault->init(localeNameBuf, FALSE);
         }
         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) {
-            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;
+        uhash_put(gDefaultLocalesHashT, (char*) newDefault->getName(), newDefault, &status);
+        if (U_FAILURE(status)) {
+            return gDefaultLocale;

         }
         }

-        umtx_unlock(NULL);

     }
     }

+    gDefaultLocale = newDefault;
+    return gDefaultLocale;

 }
 }

+

 U_NAMESPACE_END
 
 /* sfb 07/21/99 */
 U_NAMESPACE_END
 
 /* sfb 07/21/99 */


@@ -259,7 +227,8 @@ U_CFUNC void
 locale_set_default(const char *id)
 {
     U_NAMESPACE_USE
 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 */
 
 }
 /* end */
 


@@ -267,7 +236,6 @@ U_CFUNC const char *
 locale_get_default(void)
 {
     U_NAMESPACE_USE
 locale_get_default(void)
 {
     U_NAMESPACE_USE

-

     return Locale::getDefault().getName();
 }
 
     return Locale::getDefault().getName();
 }
 


@@ -283,16 +251,16 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)
 
 Locale::~Locale()
 {
 
 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 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()
 }
 
 Locale::Locale()


@@ -325,13 +293,12 @@ Locale::Locale( const   char * newLanguage,
     }
     else
     {
     }
     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;
         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.
 
 
         // Calculate the size of the resulting string.
 


@@ -339,13 +306,23 @@ Locale::Locale( const   char * newLanguage,
         if ( newLanguage != NULL )
         {
             lsize = (int32_t)uprv_strlen(newLanguage);
         if ( newLanguage != NULL )
         {
             lsize = (int32_t)uprv_strlen(newLanguage);

+            if ( lsize < 0 || lsize > ULOC_STRING_LIMIT ) { // int32 wrap
+                setToBogus();
+                return;
+            }

             size = lsize;
         }
 
             size = lsize;
         }
 

+        CharString togo(newLanguage, lsize, status); // start with newLanguage
+

         // _Country
         if ( newCountry != NULL )
         {
             csize = (int32_t)uprv_strlen(newCountry);
         // _Country
         if ( newCountry != NULL )
         {
             csize = (int32_t)uprv_strlen(newCountry);

+            if ( csize < 0 || csize > ULOC_STRING_LIMIT ) { // int32 wrap
+                setToBogus();
+                return;
+            }

             size += csize;
         }
 
             size += csize;
         }
 


@@ -360,6 +337,10 @@ Locale::Locale( const   char * newLanguage,
 
             // remove trailing _'s
             vsize = (int32_t)uprv_strlen(newVariant);
 
             // 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--;
             while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) )
             {
                 vsize--;


@@ -384,70 +365,56 @@ Locale::Locale( const   char * newLanguage,
         if ( newKeywords != NULL)
         {
             ksize = (int32_t)uprv_strlen(newKeywords);
         if ( newKeywords != NULL)
         {
             ksize = (int32_t)uprv_strlen(newKeywords);

+            if ( ksize < 0 || ksize > ULOC_STRING_LIMIT ) {
+              setToBogus();
+              return;
+            }

             size += ksize + 1;
         }
 
             size += ksize + 1;
         }
 

-

         //  NOW we have the full locale string..
         //  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.
         // 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
         {                                      //            ^
 
         if ( ( vsize != 0 ) || (csize != 0) )  // at least:  __v
         {                                      //            ^

-            *p++ = SEP_CHAR;
+            togo.append(SEP_CHAR, status);

         }
 
         if ( csize != 0 )
         {
         }
 
         if ( csize != 0 )
         {

-            uprv_strcpy(p, newCountry);
-            p += csize;
+            togo.append(newCountry, status);

         }
 
         if ( vsize != 0)
         {
         }
 
         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, '=')) {
         }
 
         if ( ksize != 0)
         {
             if (uprv_strchr(newKeywords, '=')) {

-                *p++ = '@'; /* keyword parsing */
+                togo.append('@', status); /* keyword parsing */

             }
             else {
             }
             else {

-                *p++ = '_'; /* Variant parsing with a script */
+                togo.append('_', status); /* Variant parsing with a script */

                 if ( vsize == 0) {
                 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.
         // Parse it, because for example 'language' might really be a complete
         // string.

-        init(togo.getAlias(), FALSE);
+        init(togo.data(), FALSE);

     }
 }
 
     }
 }
 


@@ -463,12 +430,11 @@ Locale &Locale::operator=(const Locale &other)
         return *this;
     }
 
         return *this;
     }
 

-    if (&other == NULL) {
-        this->setToBogus();
-        return *this;
-    }
-

     /* Free our current storage */
     /* Free our current storage */

+    if (baseName != fullName) {
+        uprv_free(baseName);
+    }
+    baseName = NULL;

     if(fullName != fullNameBuffer) {
         uprv_free(fullName);
         fullName = fullNameBuffer;
     if(fullName != fullNameBuffer) {
         uprv_free(fullName);
         fullName = fullNameBuffer;


@@ -484,18 +450,13 @@ Locale &Locale::operator=(const Locale &other)
     /* Copy the full name */
     uprv_strcpy(fullName, other.fullName);
 
     /* 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 */
     }
 
     /* Copy the language and country fields */


@@ -527,16 +488,15 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
 {
     fIsBogus = FALSE;
     /* Free our current storage */
 {
     fIsBogus = FALSE;
     /* Free our current storage */

+    if (baseName != fullName) {
+        uprv_free(baseName);
+    }
+    baseName = NULL;

     if(fullName != fullNameBuffer) {
         uprv_free(fullName);
         fullName = fullNameBuffer;
     }
 
     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
     // not a loop:
     // just an easy way to have a common error-exit
     // without goto and without another function


@@ -585,7 +545,7 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
         /* after uloc_getName/canonicalize() we know that only '_' are separators */
         separator = field[0] = fullName;
         fieldIdx = 1;
         /* 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++;
             field[fieldIdx] = separator + 1;
             fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]);
             fieldIdx++;


@@ -636,6 +596,12 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
             variantBegin = (int32_t)(field[variantField] - fullName);
         }
 
             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*/
         // successful end of init()
         return *this;
     } while(0); /*loop doesn't iterate*/


@@ -646,6 +612,43 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
     return *this;
 }
 
     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
 {
 int32_t
 Locale::hashCode() const
 {


@@ -655,37 +658,33 @@ Locale::hashCode() const
 void
 Locale::setToBogus() {
     /* Free our current storage */
 void
 Locale::setToBogus() {
     /* Free our current storage */

+    if(baseName != fullName) {
+        uprv_free(baseName);
+    }
+    baseName = NULL;

     if(fullName != fullNameBuffer) {
         uprv_free(fullName);
         fullName = fullNameBuffer;
     }
     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;
     *fullNameBuffer = 0;
     *language = 0;
     *script = 0;
     *country = 0;
     fIsBogus = TRUE;

+    variantBegin = 0;

 }
 
 const Locale& U_EXPORT2
 Locale::getDefault()
 {
 }
 
 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);
+    {
+        Mutex lock(&gDefaultLocaleMutex);
+        if (gDefaultLocale != NULL) {
+            return *gDefaultLocale;
+        }

     }
     }

-    return *retLocale;
+    UErrorCode status = U_ZERO_ERROR;
+    return *locale_set_default_internal(NULL, status);

 }
 
 
 }
 
 


@@ -702,7 +701,7 @@ Locale::setDefault( const   Locale&     newLocale,
      * This is a convenient way to access the default locale caching mechanisms.
      */
     const char *localeID = newLocale.getName();
      * This is a convenient way to access the default locale caching mechanisms.
      */
     const char *localeID = newLocale.getName();

-    locale_set_default_internal(localeID);
+    locale_set_default_internal(localeID, status);

 }
 
 Locale U_EXPORT2
 }
 
 Locale U_EXPORT2


@@ -920,46 +919,8 @@ initialization and static destruction.
 Locale *
 Locale::getLocaleCache(void)
 {
 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;
 }
 
     return gLocaleCache;
 }
 


@@ -1081,33 +1042,14 @@ void
 Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status)
 {
     uloc_setKeywordValue(keywordName, keywordValue, fullName, ULOC_FULLNAME_CAPACITY, &status);
 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 *
 }
 
 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;
 }
 
     return baseName;
 }