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 268
