icuSources/common/locutil.cpp

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