icuSources/common/locutil.cpp

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