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