1/* 2******************************************************************************* 3* Copyright (C) 1996-2014, International Business Machines 4* Corporation and others. All Rights Reserved. 5******************************************************************************* 6* file name: ucol_res.cpp 7* encoding: US-ASCII 8* tab size: 8 (not used) 9* indentation:4 10* 11* Description: 12* This file contains dependencies that the collation run-time doesn't normally 13* need. This mainly contains resource bundle usage and collation meta information 14* 15* Modification history 16* Date Name Comments 17* 1996-1999 various members of ICU team maintained C API for collation framework 18* 02/16/2001 synwee Added internal method getPrevSpecialCE 19* 03/01/2001 synwee Added maxexpansion functionality. 20* 03/16/2001 weiv Collation framework is rewritten in C and made UCA compliant 21* 12/08/2004 grhoten Split part of ucol.cpp into ucol_res.cpp 22* 2012-2014 markus Rewritten in C++ again. 23*/ 24 25#include "unicode/utypes.h" 26 27#if !UCONFIG_NO_COLLATION 28 29#include "unicode/coll.h" 30#include "unicode/localpointer.h" 31#include "unicode/locid.h" 32#include "unicode/tblcoll.h" 33#include "unicode/ucol.h" 34#include "unicode/uloc.h" 35#include "unicode/unistr.h" 36#include "unicode/ures.h" 37#include "cmemory.h" 38#include "cstring.h" 39#include "collationdatareader.h" 40#include "collationroot.h" 41#include "collationtailoring.h" 42#include "putilimp.h" 43#include "uassert.h" 44#include "ucln_in.h" 45#include "ucol_imp.h" 46#include "uenumimp.h" 47#include "ulist.h" 48#include "umutex.h" 49#include "uresimp.h" 50#include "ustrenum.h" 51#include "utracimp.h" 52 53#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) 54 55U_NAMESPACE_BEGIN 56 57namespace { 58 59static const UChar *rootRules = NULL; 60static int32_t rootRulesLength = 0; 61static UResourceBundle *rootBundle = NULL; 62static UInitOnce gInitOnce = U_INITONCE_INITIALIZER; 63 64} // namespace 65 66U_CDECL_BEGIN 67 68static UBool U_CALLCONV 69ucol_res_cleanup() { 70 rootRules = NULL; 71 rootRulesLength = 0; 72 ures_close(rootBundle); 73 rootBundle = NULL; 74 gInitOnce.reset(); 75 return TRUE; 76} 77 78U_CDECL_END 79 80void 81CollationLoader::loadRootRules(UErrorCode &errorCode) { 82 if(U_FAILURE(errorCode)) { return; } 83 rootBundle = ures_open(U_ICUDATA_COLL, kRootLocaleName, &errorCode); 84 if(U_FAILURE(errorCode)) { return; } 85 rootRules = ures_getStringByKey(rootBundle, "UCARules", &rootRulesLength, &errorCode); 86 if(U_FAILURE(errorCode)) { 87 ures_close(rootBundle); 88 rootBundle = NULL; 89 return; 90 } 91 ucln_i18n_registerCleanup(UCLN_I18N_UCOL_RES, ucol_res_cleanup); 92} 93 94void 95CollationLoader::appendRootRules(UnicodeString &s) { 96 UErrorCode errorCode = U_ZERO_ERROR; 97 umtx_initOnce(gInitOnce, CollationLoader::loadRootRules, errorCode); 98 if(U_SUCCESS(errorCode)) { 99 s.append(rootRules, rootRulesLength); 100 } 101} 102 103UnicodeString * 104CollationLoader::loadRules(const char *localeID, const char *collationType, UErrorCode &errorCode) { 105 if(U_FAILURE(errorCode)) { return NULL; } 106 U_ASSERT(collationType != NULL && *collationType != 0); 107 108 LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, localeID, &errorCode)); 109 LocalUResourceBundlePointer collations( 110 ures_getByKey(bundle.getAlias(), "collations", NULL, &errorCode)); 111 LocalUResourceBundlePointer data( 112 ures_getByKeyWithFallback(collations.getAlias(), collationType, NULL, &errorCode)); 113 int32_t length; 114 const UChar *s = ures_getStringByKey(data.getAlias(), "Sequence", &length, &errorCode); 115 if(U_FAILURE(errorCode)) { return NULL; } 116 117 // No string pointer aliasing so that we need not hold onto the resource bundle. 118 UnicodeString *rules = new UnicodeString(s, length); 119 if(rules == NULL) { 120 errorCode = U_MEMORY_ALLOCATION_ERROR; 121 return NULL; 122 } 123 return rules; 124} 125 126const CollationTailoring * 127CollationLoader::loadTailoring(const Locale &locale, Locale &validLocale, UErrorCode &errorCode) { 128 const CollationTailoring *root = CollationRoot::getRoot(errorCode); 129 if(U_FAILURE(errorCode)) { return NULL; } 130 const char *name = locale.getName(); 131 if(*name == 0 || uprv_strcmp(name, "root") == 0) { 132 validLocale = Locale::getRoot(); 133 return root; 134 } 135 136 LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, name, &errorCode)); 137 if(errorCode == U_MISSING_RESOURCE_ERROR) { 138 errorCode = U_USING_DEFAULT_WARNING; 139 validLocale = Locale::getRoot(); 140 return root; 141 } 142 const char *vLocale = ures_getLocaleByType(bundle.getAlias(), ULOC_ACTUAL_LOCALE, &errorCode); 143 if(U_FAILURE(errorCode)) { return NULL; } 144 validLocale = Locale(vLocale); 145 146 // There are zero or more tailorings in the collations table. 147 LocalUResourceBundlePointer collations( 148 ures_getByKey(bundle.getAlias(), "collations", NULL, &errorCode)); 149 if(errorCode == U_MISSING_RESOURCE_ERROR) { 150 errorCode = U_USING_DEFAULT_WARNING; 151 return root; 152 } 153 if(U_FAILURE(errorCode)) { return NULL; } 154 155 // Fetch the collation type from the locale ID and the default type from the data. 156 char type[16]; 157 int32_t typeLength = locale.getKeywordValue("collation", type, LENGTHOF(type) - 1, errorCode); 158 if(U_FAILURE(errorCode)) { 159 errorCode = U_ILLEGAL_ARGUMENT_ERROR; 160 return NULL; 161 } 162 type[typeLength] = 0; // in case of U_NOT_TERMINATED_WARNING 163 char defaultType[16]; 164 { 165 UErrorCode internalErrorCode = U_ZERO_ERROR; 166 LocalUResourceBundlePointer def( 167 ures_getByKeyWithFallback(collations.getAlias(), "default", NULL, 168 &internalErrorCode)); 169 int32_t length; 170 const UChar *s = ures_getString(def.getAlias(), &length, &internalErrorCode); 171 if(U_SUCCESS(internalErrorCode) && length < LENGTHOF(defaultType)) { 172 u_UCharsToChars(s, defaultType, length + 1); 173 } else { 174 uprv_strcpy(defaultType, "standard"); 175 } 176 } 177 if(typeLength == 0 || uprv_strcmp(type, "default") == 0) { 178 uprv_strcpy(type, defaultType); 179 } 180 181 // Load the collations/type tailoring, with type fallback. 182 UBool typeFallback = FALSE; 183 LocalUResourceBundlePointer data( 184 ures_getByKeyWithFallback(collations.getAlias(), type, NULL, &errorCode)); 185 if(errorCode == U_MISSING_RESOURCE_ERROR && 186 typeLength > 6 && uprv_strncmp(type, "search", 6) == 0) { 187 // fall back from something like "searchjl" to "search" 188 typeFallback = TRUE; 189 type[6] = 0; 190 errorCode = U_ZERO_ERROR; 191 data.adoptInstead( 192 ures_getByKeyWithFallback(collations.getAlias(), type, NULL, &errorCode)); 193 } 194 if(errorCode == U_MISSING_RESOURCE_ERROR && uprv_strcmp(type, defaultType) != 0) { 195 // fall back to the default type 196 typeFallback = TRUE; 197 uprv_strcpy(type, defaultType); 198 errorCode = U_ZERO_ERROR; 199 data.adoptInstead( 200 ures_getByKeyWithFallback(collations.getAlias(), type, NULL, &errorCode)); 201 } 202 if(errorCode == U_MISSING_RESOURCE_ERROR && uprv_strcmp(type, "standard") != 0) { 203 // fall back to the "standard" type 204 typeFallback = TRUE; 205 uprv_strcpy(type, "standard"); 206 errorCode = U_ZERO_ERROR; 207 data.adoptInstead( 208 ures_getByKeyWithFallback(collations.getAlias(), type, NULL, &errorCode)); 209 } 210 if(errorCode == U_MISSING_RESOURCE_ERROR) { 211 errorCode = U_USING_DEFAULT_WARNING; 212 return root; 213 } 214 if(U_FAILURE(errorCode)) { return NULL; } 215 216 LocalPointer<CollationTailoring> t(new CollationTailoring(root->settings)); 217 if(t.isNull() || t->isBogus()) { 218 errorCode = U_MEMORY_ALLOCATION_ERROR; 219 return NULL; 220 } 221 222 // Is this the same as the root collator? If so, then use that instead. 223 const char *actualLocale = ures_getLocaleByType(data.getAlias(), ULOC_ACTUAL_LOCALE, &errorCode); 224 if(U_FAILURE(errorCode)) { return NULL; } 225 if((*actualLocale == 0 || uprv_strcmp(actualLocale, "root") == 0) && 226 uprv_strcmp(type, "standard") == 0) { 227 if(typeFallback) { 228 errorCode = U_USING_DEFAULT_WARNING; 229 } 230 return root; 231 } 232 t->actualLocale = Locale(actualLocale); 233 234 // deserialize 235 LocalUResourceBundlePointer binary( 236 ures_getByKey(data.getAlias(), "%%CollationBin", NULL, &errorCode)); 237 // Note: U_MISSING_RESOURCE_ERROR --> The old code built from rules if available 238 // but that created undesirable dependencies. 239 int32_t length; 240 const uint8_t *inBytes = ures_getBinary(binary.getAlias(), &length, &errorCode); 241 if(U_FAILURE(errorCode)) { return NULL; } 242 CollationDataReader::read(root, inBytes, length, *t, errorCode); 243 // Note: U_COLLATOR_VERSION_MISMATCH --> The old code built from rules if available 244 // but that created undesirable dependencies. 245 if(U_FAILURE(errorCode)) { return NULL; } 246 247 // Try to fetch the optional rules string. 248 { 249 UErrorCode internalErrorCode = U_ZERO_ERROR; 250 int32_t length; 251 const UChar *s = ures_getStringByKey(data.getAlias(), "Sequence", &length, 252 &internalErrorCode); 253 if(U_SUCCESS(errorCode)) { 254 t->rules.setTo(TRUE, s, length); 255 } 256 } 257 258 // Set the collation types on the informational locales, 259 // except when they match the default types (for brevity and backwards compatibility). 260 // For the valid locale, suppress the default type. 261 if(uprv_strcmp(type, defaultType) != 0) { 262 validLocale.setKeywordValue("collation", type, errorCode); 263 if(U_FAILURE(errorCode)) { return NULL; } 264 } 265 266 // For the actual locale, suppress the default type *according to the actual locale*. 267 // For example, zh has default=pinyin and contains all of the Chinese tailorings. 268 // zh_Hant has default=stroke but has no other data. 269 // For the valid locale "zh_Hant" we need to suppress stroke. 270 // For the actual locale "zh" we need to suppress pinyin instead. 271 if(uprv_strcmp(actualLocale, vLocale) != 0) { 272 // Opening a bundle for the actual locale should always succeed. 273 LocalUResourceBundlePointer actualBundle( 274 ures_open(U_ICUDATA_COLL, actualLocale, &errorCode)); 275 if(U_FAILURE(errorCode)) { return NULL; } 276 UErrorCode internalErrorCode = U_ZERO_ERROR; 277 LocalUResourceBundlePointer def( 278 ures_getByKeyWithFallback(actualBundle.getAlias(), "collations/default", NULL, 279 &internalErrorCode)); 280 int32_t length; 281 const UChar *s = ures_getString(def.getAlias(), &length, &internalErrorCode); 282 if(U_SUCCESS(internalErrorCode) && length < LENGTHOF(defaultType)) { 283 u_UCharsToChars(s, defaultType, length + 1); 284 } else { 285 uprv_strcpy(defaultType, "standard"); 286 } 287 } 288 if(uprv_strcmp(type, defaultType) != 0) { 289 t->actualLocale.setKeywordValue("collation", type, errorCode); 290 if(U_FAILURE(errorCode)) { return NULL; } 291 } 292 293 if(typeFallback) { 294 errorCode = U_USING_DEFAULT_WARNING; 295 } 296 t->bundle = bundle.orphan(); 297 return t.orphan(); 298} 299 300U_NAMESPACE_END 301 302U_NAMESPACE_USE 303 304U_CAPI UCollator* 305ucol_open(const char *loc, 306 UErrorCode *status) 307{ 308 U_NAMESPACE_USE 309 310 UTRACE_ENTRY_OC(UTRACE_UCOL_OPEN); 311 UTRACE_DATA1(UTRACE_INFO, "locale = \"%s\"", loc); 312 UCollator *result = NULL; 313 314 Collator *coll = Collator::createInstance(loc, *status); 315 if(U_SUCCESS(*status)) { 316 result = coll->toUCollator(); 317 } 318 UTRACE_EXIT_PTR_STATUS(result, *status); 319 return result; 320} 321 322 323U_CAPI int32_t U_EXPORT2 324ucol_getDisplayName( const char *objLoc, 325 const char *dispLoc, 326 UChar *result, 327 int32_t resultLength, 328 UErrorCode *status) 329{ 330 U_NAMESPACE_USE 331 332 if(U_FAILURE(*status)) return -1; 333 UnicodeString dst; 334 if(!(result==NULL && resultLength==0)) { 335 // NULL destination for pure preflighting: empty dummy string 336 // otherwise, alias the destination buffer 337 dst.setTo(result, 0, resultLength); 338 } 339 Collator::getDisplayName(Locale(objLoc), Locale(dispLoc), dst); 340 return dst.extract(result, resultLength, *status); 341} 342 343U_CAPI const char* U_EXPORT2 344ucol_getAvailable(int32_t index) 345{ 346 int32_t count = 0; 347 const Locale *loc = Collator::getAvailableLocales(count); 348 if (loc != NULL && index < count) { 349 return loc[index].getName(); 350 } 351 return NULL; 352} 353 354U_CAPI int32_t U_EXPORT2 355ucol_countAvailable() 356{ 357 int32_t count = 0; 358 Collator::getAvailableLocales(count); 359 return count; 360} 361 362#if !UCONFIG_NO_SERVICE 363U_CAPI UEnumeration* U_EXPORT2 364ucol_openAvailableLocales(UErrorCode *status) { 365 U_NAMESPACE_USE 366 367 // This is a wrapper over Collator::getAvailableLocales() 368 if (U_FAILURE(*status)) { 369 return NULL; 370 } 371 StringEnumeration *s = icu::Collator::getAvailableLocales(); 372 if (s == NULL) { 373 *status = U_MEMORY_ALLOCATION_ERROR; 374 return NULL; 375 } 376 return uenum_openFromStringEnumeration(s, status); 377} 378#endif 379 380// Note: KEYWORDS[0] != RESOURCE_NAME - alan 381 382static const char RESOURCE_NAME[] = "collations"; 383 384static const char* const KEYWORDS[] = { "collation" }; 385 386#define KEYWORD_COUNT LENGTHOF(KEYWORDS) 387 388U_CAPI UEnumeration* U_EXPORT2 389ucol_getKeywords(UErrorCode *status) { 390 UEnumeration *result = NULL; 391 if (U_SUCCESS(*status)) { 392 return uenum_openCharStringsEnumeration(KEYWORDS, KEYWORD_COUNT, status); 393 } 394 return result; 395} 396 397U_CAPI UEnumeration* U_EXPORT2 398ucol_getKeywordValues(const char *keyword, UErrorCode *status) { 399 if (U_FAILURE(*status)) { 400 return NULL; 401 } 402 // hard-coded to accept exactly one collation keyword 403 // modify if additional collation keyword is added later 404 if (keyword==NULL || uprv_strcmp(keyword, KEYWORDS[0])!=0) 405 { 406 *status = U_ILLEGAL_ARGUMENT_ERROR; 407 return NULL; 408 } 409 return ures_getKeywordValues(U_ICUDATA_COLL, RESOURCE_NAME, status); 410} 411 412static const UEnumeration defaultKeywordValues = { 413 NULL, 414 NULL, 415 ulist_close_keyword_values_iterator, 416 ulist_count_keyword_values, 417 uenum_unextDefault, 418 ulist_next_keyword_value, 419 ulist_reset_keyword_values_iterator 420}; 421 422#include <stdio.h> 423 424U_CAPI UEnumeration* U_EXPORT2 425ucol_getKeywordValuesForLocale(const char* /*key*/, const char* locale, 426 UBool /*commonlyUsed*/, UErrorCode* status) { 427 /* Get the locale base name. */ 428 char localeBuffer[ULOC_FULLNAME_CAPACITY] = ""; 429 uloc_getBaseName(locale, localeBuffer, sizeof(localeBuffer), status); 430 431 /* Create the 2 lists 432 * -values is the temp location for the keyword values 433 * -results hold the actual list used by the UEnumeration object 434 */ 435 UList *values = ulist_createEmptyList(status); 436 UList *results = ulist_createEmptyList(status); 437 UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration)); 438 if (U_FAILURE(*status) || en == NULL) { 439 if (en == NULL) { 440 *status = U_MEMORY_ALLOCATION_ERROR; 441 } else { 442 uprv_free(en); 443 } 444 ulist_deleteList(values); 445 ulist_deleteList(results); 446 return NULL; 447 } 448 449 memcpy(en, &defaultKeywordValues, sizeof(UEnumeration)); 450 en->context = results; 451 452 /* Open the resource bundle for collation with the given locale. */ 453 UResourceBundle bundle, collations, collres, defres; 454 ures_initStackObject(&bundle); 455 ures_initStackObject(&collations); 456 ures_initStackObject(&collres); 457 ures_initStackObject(&defres); 458 459 ures_openFillIn(&bundle, U_ICUDATA_COLL, localeBuffer, status); 460 461 while (U_SUCCESS(*status)) { 462 ures_getByKey(&bundle, RESOURCE_NAME, &collations, status); 463 ures_resetIterator(&collations); 464 while (U_SUCCESS(*status) && ures_hasNext(&collations)) { 465 ures_getNextResource(&collations, &collres, status); 466 const char *key = ures_getKey(&collres); 467 /* If the key is default, get the string and store it in results list only 468 * if results list is empty. 469 */ 470 if (uprv_strcmp(key, "default") == 0) { 471 if (ulist_getListSize(results) == 0) { 472 char *defcoll = (char *)uprv_malloc(sizeof(char) * ULOC_KEYWORDS_CAPACITY); 473 int32_t defcollLength = ULOC_KEYWORDS_CAPACITY; 474 475 ures_getNextResource(&collres, &defres, status); 476#if U_CHARSET_FAMILY==U_ASCII_FAMILY 477 /* optimize - use the utf-8 string */ 478 ures_getUTF8String(&defres, defcoll, &defcollLength, TRUE, status); 479#else 480 { 481 const UChar* defString = ures_getString(&defres, &defcollLength, status); 482 if(U_SUCCESS(*status)) { 483 if(defcollLength+1 > ULOC_KEYWORDS_CAPACITY) { 484 *status = U_BUFFER_OVERFLOW_ERROR; 485 } else { 486 u_UCharsToChars(defString, defcoll, defcollLength+1); 487 } 488 } 489 } 490#endif 491 492 ulist_addItemBeginList(results, defcoll, TRUE, status); 493 } 494 } else { 495 ulist_addItemEndList(values, key, FALSE, status); 496 } 497 } 498 499 /* If the locale is "" this is root so exit. */ 500 if (uprv_strlen(localeBuffer) == 0) { 501 break; 502 } 503 /* Get the parent locale and open a new resource bundle. */ 504 uloc_getParent(localeBuffer, localeBuffer, sizeof(localeBuffer), status); 505 ures_openFillIn(&bundle, U_ICUDATA_COLL, localeBuffer, status); 506 } 507 508 ures_close(&defres); 509 ures_close(&collres); 510 ures_close(&collations); 511 ures_close(&bundle); 512 513 if (U_SUCCESS(*status)) { 514 char *value = NULL; 515 ulist_resetList(values); 516 while ((value = (char *)ulist_getNext(values)) != NULL) { 517 if (!ulist_containsString(results, value, (int32_t)uprv_strlen(value))) { 518 ulist_addItemEndList(results, value, FALSE, status); 519 if (U_FAILURE(*status)) { 520 break; 521 } 522 } 523 } 524 } 525 526 ulist_deleteList(values); 527 528 if (U_FAILURE(*status)){ 529 uenum_close(en); 530 en = NULL; 531 } else { 532 ulist_resetList(results); 533 } 534 535 return en; 536} 537 538U_CAPI int32_t U_EXPORT2 539ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity, 540 const char* keyword, const char* locale, 541 UBool* isAvailable, UErrorCode* status) 542{ 543 // N.B.: Resource name is "collations" but keyword is "collation" 544 return ures_getFunctionalEquivalent(result, resultCapacity, U_ICUDATA_COLL, 545 "collations", keyword, locale, 546 isAvailable, TRUE, status); 547} 548 549#endif /* #if !UCONFIG_NO_COLLATION */ 550