ICU-59117.0.1.tar.gz

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

diff --git a/icuSources/common/locid.cpp b/icuSources/common/locid.cpp
index cb8d59eb4c191226d697c54f0ad29d314e67e283..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-2006, International Business Machines
+ *   Copyright (C) 1997-2016, International Business Machines

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


@@ -31,18 +33,42 @@
 
 
 #include "unicode/locid.h"
 
 
 #include "unicode/locid.h"

+#include "unicode/strenum.h"

 #include "unicode/uloc.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 "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

 
 

-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+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;
+
+/**
+ * \def ULOC_STRING_LIMIT
+ * strings beyond this value crash in CharString
+ */
+#define ULOC_STRING_LIMIT 357913941
+
+U_NAMESPACE_END

 
 

-static Locale*  availableLocaleList = NULL;
-static int32_t  availableLocaleListCount;

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


@@ -63,6 +89,7 @@ typedef enum ELocalePos {
     eUS,
     eCANADA,
     eCANADA_FRENCH,
     eUS,
     eCANADA,
     eCANADA_FRENCH,

+    eROOT,

 
 
     //eDEFAULT,
 
 
     //eDEFAULT,


@@ -76,54 +103,71 @@ U_CFUNC int32_t locale_getKeywords(const char *localeID,
             UBool valuesToo,
             UErrorCode *status);
 
             UBool valuesToo,
             UErrorCode *status);
 

-static Locale        *gLocaleCache         = NULL;
-static const 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) {
 U_CDECL_BEGIN
 //
 // Deleter function for Locales owned by the default Locale hash table/
 //
 static void U_CALLCONV
 deleteLocale(void *obj) {

-    delete (Locale *) obj;
+    delete (icu::Locale *) obj;

 }
 
 static UBool U_CALLCONV locale_cleanup(void)
 {
     U_NAMESPACE_USE
 
 }
 
 static UBool U_CALLCONV locale_cleanup(void)
 {
     U_NAMESPACE_USE
 

-    if (availableLocaleList) {
-        delete []availableLocaleList;
-        availableLocaleList = NULL;
-    }
-    availableLocaleListCount = 0;
-
-    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;
 
     if (gDefaultLocalesHashT) {
         uhash_close(gDefaultLocalesHashT);   // Automatically deletes all elements, using deleter func.
         gDefaultLocalesHashT = 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

-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)

 
 

-//
-//  locale_set_default_internal.
-//
-void locale_set_default_internal(const char *id)
-{
-    U_NAMESPACE_USE
-    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


@@ -131,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) {


@@ -152,79 +189,46 @@ 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.)

+                                                 //
+    if (U_FAILURE(status)) {
+        return gDefaultLocale;
+    }

 
 

-    // Lazy creation of the hash table itself, if needed.
-    //
-    umtx_lock(NULL);
-    UBool hashTableNeedsInit = (gDefaultLocalesHashT == NULL);
-    umtx_unlock(NULL);
-    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);
-            umtx_unlock(NULL);
-        } else {
-            umtx_unlock(NULL);
-            uhash_close(tHashTable);
+            return gDefaultLocale;

         }
         }

+        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);
-        const Locale *hashTableVal = (const Locale *)uhash_get(gDefaultLocalesHashT, key);
-        if (hashTableVal == NULL) {
-            uhash_put(gDefaultLocalesHashT, (void *)key, newDefault, &status);
-            gDefaultLocale = newDefault;
-            umtx_unlock(NULL);
-            // 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
-            umtx_unlock(NULL);
-            delete newDefault;
+        uhash_put(gDefaultLocalesHashT, (char*) newDefault->getName(), newDefault, &status);
+        if (U_FAILURE(status)) {
+            return gDefaultLocale;

         }
     }
         }
     }

+    gDefaultLocale = newDefault;
+    return gDefaultLocale;

 }
 }

-U_NAMESPACE_END

 
 

+U_NAMESPACE_END

 
 /* sfb 07/21/99 */
 U_CFUNC void
 locale_set_default(const char *id)
 {
     U_NAMESPACE_USE
 
 /* sfb 07/21/99 */
 U_CFUNC void
 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 */
 


@@ -232,13 +236,14 @@ U_CFUNC const char *
 locale_get_default(void)
 {
     U_NAMESPACE_USE
 locale_get_default(void)
 {
     U_NAMESPACE_USE

-

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

+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)
+

 /*Character separating the posix id fields*/
 // '_'
 // In the platform codepage.
 /*Character separating the posix id fields*/
 // '_'
 // In the platform codepage.


@@ -246,16 +251,16 @@ U_NAMESPACE_BEGIN
 
 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()


@@ -288,15 +293,12 @@ Locale::Locale( const   char * newLanguage,
     }
     else
     {
     }
     else
     {

-        char togo_stack[ULOC_FULLNAME_CAPACITY];
-        char *togo;
-        char *togo_heap = NULL;
+        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.
 


@@ -304,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;
         }
 


@@ -325,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--;


@@ -349,76 +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 >= ULOC_FULLNAME_CAPACITY)
-        {
-            togo_heap = (char *)uprv_malloc(sizeof(char)*(size+1));
-            togo = togo_heap;
-        }
-        else
-        {
-            togo = togo_stack;
-        }
-
-        togo[0] = 0;
-

         // Now, copy it back.
         // Now, copy it back.

-        p = togo;
-        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, FALSE);
-
-        if (togo_heap) {
-            uprv_free(togo_heap);
-        }
+        init(togo.data(), FALSE);

     }
 }
 
     }
 }
 


@@ -434,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;


@@ -448,22 +443,20 @@ Locale &Locale::operator=(const Locale &other)
     /* Allocate the full name if necessary */
     if(other.fullName != other.fullNameBuffer) {
         fullName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(other.fullName)+1));
     /* 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 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 */


@@ -471,7 +464,7 @@ Locale &Locale::operator=(const Locale &other)
     uprv_strcpy(script, other.script);
     uprv_strcpy(country, other.country);
 
     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;
     variantBegin = other.variantBegin;
     fIsBogus = other.fIsBogus;
     return *this;


@@ -488,21 +481,22 @@ Locale::operator==( const   Locale& other) const
     return (uprv_strcmp(other.fullName, fullName) == 0);
 }
 
     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 */
 /*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 (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


@@ -551,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++;


@@ -568,40 +562,46 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
             fieldLen[fieldIdx-1] = length - (int32_t)(field[fieldIdx-1] - fullName);
         }
 
             fieldLen[fieldIdx-1] = length - (int32_t)(field[fieldIdx-1] - fullName);
         }
 

-        if (fieldLen[0] >= (int32_t)(sizeof(language))
-            || (fieldLen[1] == 4 && fieldLen[2] >= (int32_t)(sizeof(country)))
-            || (fieldLen[1] != 4 && fieldLen[1] >= (int32_t)(sizeof(country))))
+        if (fieldLen[0] >= (int32_t)(sizeof(language)))

         {
         {

-            break; // error: one of the fields is too long
+            break; // error: the language field is too long

         }
 
         }
 

-        variantField = 2; /* Usually the 2nd one, except when a script is used. */
+        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[0] > 0) {
             /* We have a language */
             uprv_memcpy(language, fullName, fieldLen[0]);
             language[fieldLen[0]] = 0;
         }

-        if (fieldLen[1] == 4) {
+        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;
             /* We have at least a script */
             uprv_memcpy(script, field[1], fieldLen[1]);
             script[fieldLen[1]] = 0;

-            variantField = 3;
-            if (fieldLen[2] > 0) {
-                /* We have a country */
-                uprv_memcpy(country, field[2], fieldLen[2]);
-                country[fieldLen[2]] = 0;
-            }
+            variantField++;

         }
         }

-        else if (fieldLen[1] > 0) {
-            /* We have a country and no script */
-            uprv_memcpy(country, field[1], fieldLen[1]);
-            country[fieldLen[1]] = 0;
+
+        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 (variantField > 0 && fieldLen[variantField] > 0) {
+
+        if (fieldLen[variantField] > 0) {

             /* We have a variant */
             variantBegin = (int32_t)(field[variantField] - fullName);
         }
 
             /* 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); /*loop doesn't iterate*/
         // successful end of init()
         return *this;
     } while(0); /*loop doesn't iterate*/


@@ -612,17 +612,56 @@ 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
 {

-    UHashTok hashKey;
-    hashKey.pointer = fullName;
-    return uhash_hashChars(hashKey);
+    return ustr_hashCharsN(fullName, uprv_strlen(fullName));

 }
 
 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;


@@ -632,26 +671,20 @@ Locale::setToBogus() {
     *script = 0;
     *country = 0;
     fIsBogus = TRUE;
     *script = 0;
     *country = 0;
     fIsBogus = TRUE;

+    variantBegin = 0;

 }
 
 const Locale& U_EXPORT2
 Locale::getDefault()
 {
 }
 
 const Locale& U_EXPORT2
 Locale::getDefault()
 {

-    const Locale *retLocale;
-    umtx_lock(NULL);
-    retLocale = gDefaultLocale;
-    umtx_unlock(NULL);
-    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);

 }
 
 
 }
 
 


@@ -668,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


@@ -717,250 +750,6 @@ Locale::getLCID() const
     return uloc_getLCID(fullName);
 }
 
     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(U_SUCCESS(errorCode) ? length : 0);
-
-    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(U_SUCCESS(errorCode) ? length : 0);
-    }
-
-    return result;
-}
-
-UnicodeString&
-Locale::getDisplayScript(UnicodeString& dispScript) const
-{
-    return this->getDisplayScript(getDefault(), dispScript);
-}
-
-UnicodeString&
-Locale::getDisplayScript(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_getDisplayScript(fullName, displayLocale.fullName,
-                                  buffer, result.getCapacity(),
-                                  &errorCode);
-    result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
-
-    if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
-        buffer=result.getBuffer(length);
-        if(buffer==0) {
-            result.truncate(0);
-            return result;
-        }
-        errorCode=U_ZERO_ERROR;
-        length=uloc_getDisplayScript(fullName, displayLocale.fullName,
-                                      buffer, result.getCapacity(),
-                                      &errorCode);
-        result.releaseBuffer(U_SUCCESS(errorCode) ? length : 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(U_SUCCESS(errorCode) ? length : 0);
-
-    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(U_SUCCESS(errorCode) ? length : 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(U_SUCCESS(errorCode) ? length : 0);
-
-    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(U_SUCCESS(errorCode) ? length : 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(U_SUCCESS(errorCode) ? length : 0);
-
-    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(U_SUCCESS(errorCode) ? length : 0);
-    }
-
-    return result;
-}
-const Locale* U_EXPORT2
-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) {
-            count = 0;
-            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;
-            ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
-        }
-        umtx_unlock(NULL);
-        delete []newLocaleList;
-    }
-    count = availableLocaleListCount;
-    return availableLocaleList;
-}
-

 const char* const* U_EXPORT2 Locale::getISOCountries()
 {
     return uloc_getISOCountries();
 const char* const* U_EXPORT2 Locale::getISOCountries()
 {
     return uloc_getISOCountries();


@@ -977,6 +766,12 @@ void Locale::setFromPOSIXID(const char *posixID)
     init(posixID, TRUE);
 }
 
     init(posixID, TRUE);
 }
 

+const Locale & U_EXPORT2
+Locale::getRoot(void)
+{
+    return getLocale(eROOT);
+}
+

 const Locale & U_EXPORT2
 Locale::getEnglish(void)
 {
 const Locale & U_EXPORT2
 Locale::getEnglish(void)
 {


@@ -1124,45 +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[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;
 }
 


@@ -1198,9 +956,7 @@ public:
         }
     }
 
         }
     }
 

-    virtual ~KeywordEnumeration() {
-        uprv_free(keywords);
-    }
+    virtual ~KeywordEnumeration();

 
     virtual StringEnumeration * clone() const
     {
 
     virtual StringEnumeration * clone() const
     {


@@ -1250,6 +1006,10 @@ public:
 
 const char KeywordEnumeration::fgClassID = '\0';
 
 
 const char KeywordEnumeration::fgClassID = '\0';
 

+KeywordEnumeration::~KeywordEnumeration() {
+    uprv_free(keywords);
+}
+

 StringEnumeration *
 Locale::createKeywords(UErrorCode &status) const
 {
 StringEnumeration *
 Locale::createKeywords(UErrorCode &status) const
 {


@@ -1278,24 +1038,20 @@ Locale::getKeywordValue(const char* keywordName, char *buffer, int32_t bufLen, U
     return uloc_getKeywordValue(fullName, keywordName, buffer, bufLen, &status);
 }
 
     return uloc_getKeywordValue(fullName, keywordName, buffer, bufLen, &status);
 }
 

-const char *
-Locale::getBaseName() const
+void
+Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status)

 {
 {

-    // 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);
-            uloc_getBaseName(fullName, baseName, baseNameSize+1, &status);
-        }
-        baseName[baseNameSize] = 0;
+    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);

     }
     }

-    return baseName;

 }
 
 }
 

+const char *
+Locale::getBaseName() const {
+    return baseName;
+}

 
 //eof
 U_NAMESPACE_END
 
 //eof
 U_NAMESPACE_END