src/third_party/icu/source/common/locutil.cpp

   1 /*
   2  *******************************************************************************
   3  * Copyright (C) 2002-2011, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  *******************************************************************************
   6  */
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_SERVICE || !UCONFIG_NO_TRANSLITERATION
  10
  11 #include "unicode/resbund.h"
  12 #include "cmemory.h"
  13 #include "ustrfmt.h"
  14 #include "locutil.h"
  15 #include "charstr.h"
  16 #include "ucln_cmn.h"
  17 #include "uassert.h"
  18 #include "umutex.h"
  19
  20 // see LocaleUtility::getAvailableLocaleNames
  21 static icu::Hashtable * LocaleUtility_cache = NULL;
  22
  23 #define UNDERSCORE_CHAR ((UChar)0x005f)
  24 #define AT_SIGN_CHAR    ((UChar)64)
  25 #define PERIOD_CHAR     ((UChar)46)
  26
  27 /*
  28  ******************************************************************
  29  */
  30
  31 /**
  32  * Release all static memory held by Locale Utility.
  33  */
  34 U_CDECL_BEGIN
  35 static UBool U_CALLCONV service_cleanup(void) {
  36     if (LocaleUtility_cache) {
  37         delete LocaleUtility_cache;
  38         LocaleUtility_cache = NULL;
  39     }
  40     return TRUE;
  41 }
  42 U_CDECL_END
  43
  44 U_NAMESPACE_BEGIN
  45
  46 UnicodeString&
  47 LocaleUtility::canonicalLocaleString(const UnicodeString* id, UnicodeString& result)
  48 {
  49   if (id == NULL) {
  50     result.setToBogus();
  51   } else {
  52     // Fix case only (no other changes) up to the first '@' or '.' or
  53     // end of string, whichever comes first.  In 3.0 I changed this to
  54     // stop at first '@' or '.'.  It used to run out to the end of
  55     // string.  My fix makes the tests pass but is probably
  56     // structurally incorrect.  See below.  [alan 3.0]
  57
  58     // TODO: Doug, you might want to revise this...
  59     result = *id;
  60     int32_t i = 0;
  61     int32_t end = result.indexOf(AT_SIGN_CHAR);
  62     int32_t n = result.indexOf(PERIOD_CHAR);
  63     if (n >= 0 && n < end) {
  64         end = n;
  65     }
  66     if (end < 0) {
  67         end = result.length();
  68     }
  69     n = result.indexOf(UNDERSCORE_CHAR);
  70     if (n < 0) {
  71       n = end;
  72     }
  73     for (; i < n; ++i) {
  74       UChar c = result.charAt(i);
  75       if (c >= 0x0041 && c <= 0x005a) {
  76         c += 0x20;
  77         result.setCharAt(i, c);
  78       }
  79     }
  80     for (n = end; i < n; ++i) {
  81       UChar c = result.charAt(i);
  82       if (c >= 0x0061 && c <= 0x007a) {
  83         c -= 0x20;
  84         result.setCharAt(i, c);
  85       }
  86     }
  87   }
  88   return result;
  89
  90 #if 0
  91     // This code does a proper full level 2 canonicalization of id.
  92     // It's nasty to go from UChar to char to char to UChar -- but
  93     // that's what you have to do to use the uloc_canonicalize
  94     // function on UnicodeStrings.
  95
  96     // I ended up doing the alternate fix (see above) not for
  97     // performance reasons, although performance will certainly be
  98     // better, but because doing a full level 2 canonicalization
  99     // causes some tests to fail.  [alan 3.0]
 100
 101     // TODO: Doug, you might want to revisit this...
 102     result.setToBogus();
 103     if (id != 0) {
 104         int32_t buflen = id->length() + 8; // space for NUL
 105         char* buf = (char*) uprv_malloc(buflen);
 106         char* canon = (buf == 0) ? 0 : (char*) uprv_malloc(buflen);
 107         if (buf != 0 && canon != 0) {
 108             U_ASSERT(id->extract(0, INT32_MAX, buf, buflen) < buflen);
 109             UErrorCode ec = U_ZERO_ERROR;
 110             uloc_canonicalize(buf, canon, buflen, &ec);
 111             if (U_SUCCESS(ec)) {
 112                 result = UnicodeString(canon);
 113             }
 114         }
 115         uprv_free(buf);
 116         uprv_free(canon);
 117     }
 118     return result;
 119 #endif
 120 }
 121
 122 Locale&
 123 LocaleUtility::initLocaleFromName(const UnicodeString& id, Locale& result)
 124 {
 125     enum { BUFLEN = 128 }; // larger than ever needed
 126
 127     if (id.isBogus() || id.length() >= BUFLEN) {
 128         result.setToBogus();
 129     } else {
 130         /*
 131          * We need to convert from a UnicodeString to char * in order to
 132          * create a Locale.
 133          *
 134          * Problem: Locale ID strings may contain '@' which is a variant
 135          * character and cannot be handled by invariant-character conversion.
 136          *
 137          * Hack: Since ICU code can handle locale IDs with multiple encodings
 138          * of '@' (at least for EBCDIC; it's not known to be a problem for
 139          * ASCII-based systems),
 140          * we use regular invariant-character conversion for everything else
 141          * and manually convert U+0040 into a compiler-char-constant '@'.
 142          * While this compilation-time constant may not match the runtime
 143          * encoding of '@', it should be one of the encodings which ICU
 144          * recognizes.
 145          *
 146          * There should be only at most one '@' in a locale ID.
 147          */
 148         char buffer[BUFLEN];
 149         int32_t prev, i;
 150         prev = 0;
 151         for(;;) {
 152             i = id.indexOf((UChar)0x40, prev);
 153             if(i < 0) {
 154                 // no @ between prev and the rest of the string
 155                 id.extract(prev, INT32_MAX, buffer + prev, BUFLEN - prev, US_INV);
 156                 break; // done
 157             } else {
 158                 // normal invariant-character conversion for text between @s
 159                 id.extract(prev, i - prev, buffer + prev, BUFLEN - prev, US_INV);
 160                 // manually "convert" U+0040 at id[i] into '@' at buffer[i]
 161                 buffer[i] = '@';
 162                 prev = i + 1;
 163             }
 164         }
 165         result = Locale::createFromName(buffer);
 166     }
 167     return result;
 168 }
 169
 170 UnicodeString&
 171 LocaleUtility::initNameFromLocale(const Locale& locale, UnicodeString& result)
 172 {
 173     if (locale.isBogus()) {
 174         result.setToBogus();
 175     } else {
 176         result.append(UnicodeString(locale.getName(), -1, US_INV));
 177     }
 178     return result;
 179 }
 180
 181 const Hashtable*
 182 LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID)
 183 {
 184     // LocaleUtility_cache is a hash-of-hashes.  The top-level keys
 185     // are path strings ('bundleID') passed to
 186     // ures_openAvailableLocales.  The top-level values are
 187     // second-level hashes.  The second-level keys are result strings
 188     // from ures_openAvailableLocales.  The second-level values are
 189     // garbage ((void*)1 or other random pointer).
 190
 191     UErrorCode status = U_ZERO_ERROR;
 192     Hashtable* cache;
 193     umtx_lock(NULL);
 194     cache = LocaleUtility_cache;
 195     umtx_unlock(NULL);
 196
 197     if (cache == NULL) {
 198         cache = new Hashtable(status);
 199         if (cache == NULL || U_FAILURE(status)) {
 200             return NULL; // catastrophic failure; e.g. out of memory
 201         }
 202         cache->setValueDeleter(uhash_deleteHashtable);
 203         Hashtable* h; // set this to final LocaleUtility_cache value
 204         umtx_lock(NULL);
 205         h = LocaleUtility_cache;
 206         if (h == NULL) {
 207             LocaleUtility_cache = h = cache;
 208             cache = NULL;
 209             ucln_common_registerCleanup(UCLN_COMMON_SERVICE, service_cleanup);
 210         }
 211         umtx_unlock(NULL);
 212         if(cache != NULL) {
 213           delete cache;
 214         }
 215         cache = h;
 216     }
 217
 218     U_ASSERT(cache != NULL);
 219
 220     Hashtable* htp;
 221     umtx_lock(NULL);
 222     htp = (Hashtable*) cache->get(bundleID);
 223     umtx_unlock(NULL);
 224
 225     if (htp == NULL) {
 226         htp = new Hashtable(status);
 227         if (htp && U_SUCCESS(status)) {
 228             CharString cbundleID;
 229             cbundleID.appendInvariantChars(bundleID, status);
 230             const char* path = cbundleID.isEmpty() ? NULL : cbundleID.data();
 231             UEnumeration *uenum = ures_openAvailableLocales(path, &status);
 232             for (;;) {
 233                 const UChar* id = uenum_unext(uenum, NULL, &status);
 234                 if (id == NULL) {
 235                     break;
 236                 }
 237                 htp->put(UnicodeString(id), (void*)htp, status);
 238             }
 239             uenum_close(uenum);
 240             if (U_FAILURE(status)) {
 241                 delete htp;
 242                 return NULL;
 243             }
 244             umtx_lock(NULL);
 245             cache->put(bundleID, (void*)htp, status);
 246             umtx_unlock(NULL);
 247         }
 248     }
 249     return htp;
 250 }
 251
 252 UBool
 253 LocaleUtility::isFallbackOf(const UnicodeString& root, const UnicodeString& child)
 254 {
 255     return child.indexOf(root) == 0 &&
 256       (child.length() == root.length() ||
 257        child.charAt(root.length()) == UNDERSCORE_CHAR);
 258 }
 259
 260 U_NAMESPACE_END
 261
 262 /* !UCONFIG_NO_SERVICE */
 263 #endif
 264
 265