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