Home | History | Annotate | Download | only in common
      1 /**
      2  *******************************************************************************
      3  * Copyright (C) 2002-2010, 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 U_NAMESPACE_QUALIFIER 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 
    266