OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ********************************************************************** |
| 3 * Copyright (C) 2014, International Business Machines |
| 4 * Corporation and others. All Rights Reserved. |
| 5 ********************************************************************** |
| 6 */ |
| 7 #include "unicode/utypes.h" |
| 8 |
| 9 #include "cstring.h" |
| 10 #include "uassert.h" |
| 11 #include "ucln_cmn.h" |
| 12 #include "uhash.h" |
| 13 #include "umutex.h" |
| 14 #include "uresimp.h" |
| 15 #include "uvector.h" |
| 16 |
| 17 static UHashtable* gLocExtKeyMap = NULL; |
| 18 static icu::UInitOnce gLocExtKeyMapInitOnce = U_INITONCE_INITIALIZER; |
| 19 static icu::UVector* gKeyTypeStringPool = NULL; |
| 20 static icu::UVector* gLocExtKeyDataEntries = NULL; |
| 21 static icu::UVector* gLocExtTypeEntries = NULL; |
| 22 |
| 23 // bit flags for special types |
| 24 typedef enum { |
| 25 SPECIALTYPE_NONE = 0, |
| 26 SPECIALTYPE_CODEPOINTS = 1, |
| 27 SPECIALTYPE_REORDER_CODE = 2 |
| 28 } SpecialType; |
| 29 |
| 30 typedef struct LocExtKeyData { |
| 31 const char* legacyId; |
| 32 const char* bcpId; |
| 33 UHashtable* typeMap; |
| 34 uint32_t specialTypes; |
| 35 } LocExtKeyData; |
| 36 |
| 37 typedef struct LocExtType { |
| 38 const char* legacyId; |
| 39 const char* bcpId; |
| 40 } LocExtType; |
| 41 |
| 42 U_CDECL_BEGIN |
| 43 |
| 44 static UBool U_CALLCONV |
| 45 uloc_key_type_cleanup(void) { |
| 46 if (gLocExtKeyMap != NULL) { |
| 47 uhash_close(gLocExtKeyMap); |
| 48 gLocExtKeyMap = NULL; |
| 49 } |
| 50 |
| 51 delete gLocExtKeyDataEntries; |
| 52 gLocExtKeyDataEntries = NULL; |
| 53 |
| 54 delete gLocExtTypeEntries; |
| 55 gLocExtTypeEntries = NULL; |
| 56 |
| 57 delete gKeyTypeStringPool; |
| 58 gKeyTypeStringPool = NULL; |
| 59 |
| 60 gLocExtKeyMapInitOnce.reset(); |
| 61 return TRUE; |
| 62 } |
| 63 |
| 64 static void U_CALLCONV |
| 65 uloc_deleteKeyTypeStringPoolEntry(void* obj) { |
| 66 uprv_free(obj); |
| 67 } |
| 68 |
| 69 static void U_CALLCONV |
| 70 uloc_deleteKeyDataEntry(void* obj) { |
| 71 LocExtKeyData* keyData = (LocExtKeyData*)obj; |
| 72 if (keyData->typeMap != NULL) { |
| 73 uhash_close(keyData->typeMap); |
| 74 } |
| 75 uprv_free(keyData); |
| 76 } |
| 77 |
| 78 static void U_CALLCONV |
| 79 uloc_deleteTypeEntry(void* obj) { |
| 80 uprv_free(obj); |
| 81 } |
| 82 |
| 83 U_CDECL_END |
| 84 |
| 85 |
| 86 static void U_CALLCONV |
| 87 initFromResourceBundle(UErrorCode& sts) { |
| 88 U_NAMESPACE_USE |
| 89 ucln_common_registerCleanup(UCLN_COMMON_LOCALE_KEY_TYPE, uloc_key_type_clean
up); |
| 90 |
| 91 gLocExtKeyMap = uhash_open(uhash_hashIChars, uhash_compareIChars, NULL, &sts
); |
| 92 |
| 93 LocalUResourceBundlePointer keyTypeDataRes(ures_openDirect(NULL, "keyTypeDat
a", &sts)); |
| 94 LocalUResourceBundlePointer keyMapRes(ures_getByKey(keyTypeDataRes.getAlias(
), "keyMap", NULL, &sts)); |
| 95 LocalUResourceBundlePointer typeMapRes(ures_getByKey(keyTypeDataRes.getAlias
(), "typeMap", NULL, &sts)); |
| 96 |
| 97 if (U_FAILURE(sts)) { |
| 98 return; |
| 99 } |
| 100 |
| 101 UErrorCode tmpSts = U_ZERO_ERROR; |
| 102 LocalUResourceBundlePointer typeAliasRes(ures_getByKey(keyTypeDataRes.getAli
as(), "typeAlias", NULL, &tmpSts)); |
| 103 tmpSts = U_ZERO_ERROR; |
| 104 LocalUResourceBundlePointer bcpTypeAliasRes(ures_getByKey(keyTypeDataRes.get
Alias(), "bcpTypeAlias", NULL, &tmpSts)); |
| 105 |
| 106 // initialize vectors storing dynamically allocated objects |
| 107 gKeyTypeStringPool = new UVector(uloc_deleteKeyTypeStringPoolEntry, NULL, st
s); |
| 108 if (gKeyTypeStringPool == NULL) { |
| 109 if (U_SUCCESS(sts)) { |
| 110 sts = U_MEMORY_ALLOCATION_ERROR; |
| 111 } |
| 112 } |
| 113 if (U_FAILURE(sts)) { |
| 114 return; |
| 115 } |
| 116 gLocExtKeyDataEntries = new UVector(uloc_deleteKeyDataEntry, NULL, sts); |
| 117 if (gLocExtKeyDataEntries == NULL) { |
| 118 if (U_SUCCESS(sts)) { |
| 119 sts = U_MEMORY_ALLOCATION_ERROR; |
| 120 } |
| 121 } |
| 122 if (U_FAILURE(sts)) { |
| 123 return; |
| 124 } |
| 125 gLocExtTypeEntries = new UVector(uloc_deleteTypeEntry, NULL, sts); |
| 126 if (gLocExtTypeEntries == NULL) { |
| 127 if (U_SUCCESS(sts)) { |
| 128 sts = U_MEMORY_ALLOCATION_ERROR; |
| 129 } |
| 130 } |
| 131 if (U_FAILURE(sts)) { |
| 132 return; |
| 133 } |
| 134 |
| 135 // iterate through keyMap resource |
| 136 LocalUResourceBundlePointer keyMapEntry; |
| 137 |
| 138 while (ures_hasNext(keyMapRes.getAlias())) { |
| 139 keyMapEntry.adoptInstead(ures_getNextResource(keyMapRes.getAlias(), keyM
apEntry.orphan(), &sts)); |
| 140 if (U_FAILURE(sts)) { |
| 141 break; |
| 142 } |
| 143 const char* legacyKeyId = ures_getKey(keyMapEntry.getAlias()); |
| 144 int32_t bcpKeyIdLen = 0; |
| 145 const UChar* uBcpKeyId = ures_getString(keyMapEntry.getAlias(), &bcpKeyI
dLen, &sts); |
| 146 if (U_FAILURE(sts)) { |
| 147 break; |
| 148 } |
| 149 |
| 150 // empty value indicates that BCP key is same with the legacy key. |
| 151 const char* bcpKeyId = legacyKeyId; |
| 152 if (bcpKeyIdLen > 0) { |
| 153 char* bcpKeyIdBuf = (char*)uprv_malloc(bcpKeyIdLen + 1); |
| 154 if (bcpKeyIdBuf == NULL) { |
| 155 sts = U_MEMORY_ALLOCATION_ERROR; |
| 156 break; |
| 157 } |
| 158 u_UCharsToChars(uBcpKeyId, bcpKeyIdBuf, bcpKeyIdLen); |
| 159 bcpKeyIdBuf[bcpKeyIdLen] = 0; |
| 160 gKeyTypeStringPool->addElement(bcpKeyIdBuf, sts); |
| 161 if (U_FAILURE(sts)) { |
| 162 break; |
| 163 } |
| 164 bcpKeyId = bcpKeyIdBuf; |
| 165 } |
| 166 |
| 167 UBool isTZ = uprv_strcmp(legacyKeyId, "timezone") == 0; |
| 168 |
| 169 UHashtable* typeDataMap = uhash_open(uhash_hashIChars, uhash_compareICha
rs, NULL, &sts); |
| 170 if (U_FAILURE(sts)) { |
| 171 break; |
| 172 } |
| 173 uint32_t specialTypes = SPECIALTYPE_NONE; |
| 174 |
| 175 LocalUResourceBundlePointer typeAliasResByKey; |
| 176 LocalUResourceBundlePointer bcpTypeAliasResByKey; |
| 177 |
| 178 if (typeAliasRes.isValid()) { |
| 179 tmpSts = U_ZERO_ERROR; |
| 180 typeAliasResByKey.adoptInstead(ures_getByKey(typeAliasRes.getAlias()
, legacyKeyId, NULL, &tmpSts)); |
| 181 if (U_FAILURE(tmpSts)) { |
| 182 typeAliasResByKey.orphan(); |
| 183 } |
| 184 } |
| 185 if (bcpTypeAliasRes.isValid()) { |
| 186 tmpSts = U_ZERO_ERROR; |
| 187 bcpTypeAliasResByKey.adoptInstead(ures_getByKey(bcpTypeAliasRes.getA
lias(), bcpKeyId, NULL, &tmpSts)); |
| 188 if (U_FAILURE(tmpSts)) { |
| 189 bcpTypeAliasResByKey.orphan(); |
| 190 } |
| 191 } |
| 192 |
| 193 // look up type map for the key, and walk through the mapping data |
| 194 tmpSts = U_ZERO_ERROR; |
| 195 LocalUResourceBundlePointer typeMapResByKey(ures_getByKey(typeMapRes.get
Alias(), legacyKeyId, NULL, &tmpSts)); |
| 196 if (U_FAILURE(tmpSts)) { |
| 197 // type map for each key must exist |
| 198 U_ASSERT(FALSE); |
| 199 } else { |
| 200 LocalUResourceBundlePointer typeMapEntry; |
| 201 |
| 202 while (ures_hasNext(typeMapResByKey.getAlias())) { |
| 203 typeMapEntry.adoptInstead(ures_getNextResource(typeMapResByKey.g
etAlias(), typeMapEntry.orphan(), &sts)); |
| 204 if (U_FAILURE(sts)) { |
| 205 break; |
| 206 } |
| 207 const char* legacyTypeId = ures_getKey(typeMapEntry.getAlias()); |
| 208 |
| 209 // special types |
| 210 if (uprv_strcmp(legacyTypeId, "CODEPOINTS") == 0) { |
| 211 specialTypes |= SPECIALTYPE_CODEPOINTS; |
| 212 continue; |
| 213 } |
| 214 if (uprv_strcmp(legacyTypeId, "REORDER_CODE") == 0) { |
| 215 specialTypes |= SPECIALTYPE_REORDER_CODE; |
| 216 continue; |
| 217 } |
| 218 |
| 219 if (isTZ) { |
| 220 // a timezone key uses a colon instead of a slash in the res
ource. |
| 221 // e.g. America:Los_Angeles |
| 222 if (uprv_strchr(legacyTypeId, ':') != NULL) { |
| 223 int32_t legacyTypeIdLen = uprv_strlen(legacyTypeId); |
| 224 char* legacyTypeIdBuf = (char*)uprv_malloc(legacyTypeIdL
en + 1); |
| 225 if (legacyTypeIdBuf == NULL) { |
| 226 sts = U_MEMORY_ALLOCATION_ERROR; |
| 227 break; |
| 228 } |
| 229 const char* p = legacyTypeId; |
| 230 char* q = legacyTypeIdBuf; |
| 231 while (*p) { |
| 232 if (*p == ':') { |
| 233 *q++ = '/'; |
| 234 } else { |
| 235 *q++ = *p; |
| 236 } |
| 237 p++; |
| 238 } |
| 239 *q = 0; |
| 240 |
| 241 gKeyTypeStringPool->addElement(legacyTypeIdBuf, sts); |
| 242 if (U_FAILURE(sts)) { |
| 243 break; |
| 244 } |
| 245 legacyTypeId = legacyTypeIdBuf; |
| 246 } |
| 247 } |
| 248 |
| 249 int32_t bcpTypeIdLen = 0; |
| 250 const UChar* uBcpTypeId = ures_getString(typeMapEntry.getAlias()
, &bcpTypeIdLen, &sts); |
| 251 if (U_FAILURE(sts)) { |
| 252 break; |
| 253 } |
| 254 |
| 255 // empty value indicates that BCP type is same with the legacy t
ype. |
| 256 const char* bcpTypeId = legacyTypeId; |
| 257 if (bcpTypeIdLen > 0) { |
| 258 char* bcpTypeIdBuf = (char*)uprv_malloc(bcpTypeIdLen + 1); |
| 259 if (bcpTypeIdBuf == NULL) { |
| 260 sts = U_MEMORY_ALLOCATION_ERROR; |
| 261 break; |
| 262 } |
| 263 u_UCharsToChars(uBcpTypeId, bcpTypeIdBuf, bcpTypeIdLen); |
| 264 bcpTypeIdBuf[bcpTypeIdLen] = 0; |
| 265 gKeyTypeStringPool->addElement(bcpTypeIdBuf, sts); |
| 266 if (U_FAILURE(sts)) { |
| 267 break; |
| 268 } |
| 269 bcpTypeId = bcpTypeIdBuf; |
| 270 } |
| 271 |
| 272 // Note: legacy type value should never be |
| 273 // equivalent to bcp type value of a different |
| 274 // type under the same key. So we use a single |
| 275 // map for lookup. |
| 276 LocExtType* t = (LocExtType*)uprv_malloc(sizeof(LocExtType)); |
| 277 if (t == NULL) { |
| 278 sts = U_MEMORY_ALLOCATION_ERROR; |
| 279 break; |
| 280 } |
| 281 t->bcpId = bcpTypeId; |
| 282 t->legacyId = legacyTypeId; |
| 283 gLocExtTypeEntries->addElement((void*)t, sts); |
| 284 if (U_FAILURE(sts)) { |
| 285 break; |
| 286 } |
| 287 |
| 288 uhash_put(typeDataMap, (void*)legacyTypeId, t, &sts); |
| 289 if (bcpTypeId != legacyTypeId) { |
| 290 // different type value |
| 291 uhash_put(typeDataMap, (void*)bcpTypeId, t, &sts); |
| 292 } |
| 293 if (U_FAILURE(sts)) { |
| 294 break; |
| 295 } |
| 296 |
| 297 // also put aliases in the map |
| 298 if (typeAliasResByKey.isValid()) { |
| 299 LocalUResourceBundlePointer typeAliasDataEntry; |
| 300 |
| 301 ures_resetIterator(typeAliasResByKey.getAlias()); |
| 302 while (ures_hasNext(typeAliasResByKey.getAlias()) && U_SUCCE
SS(sts)) { |
| 303 int32_t toLen; |
| 304 typeAliasDataEntry.adoptInstead(ures_getNextResource(typ
eAliasResByKey.getAlias(), typeAliasDataEntry.orphan(), &sts)); |
| 305 const UChar* to = ures_getString(typeAliasDataEntry.getA
lias(), &toLen, &sts); |
| 306 if (U_FAILURE(sts)) { |
| 307 break; |
| 308 } |
| 309 // check if this is an alias of canoncal legacy type |
| 310 if (uprv_compareInvAscii(NULL, legacyTypeId, -1, to, toL
en) == 0) { |
| 311 const char* from = ures_getKey(typeAliasDataEntry.ge
tAlias()); |
| 312 if (isTZ) { |
| 313 // replace colon with slash if necessary |
| 314 if (uprv_strchr(from, ':') != NULL) { |
| 315 int32_t fromLen = uprv_strlen(from); |
| 316 char* fromBuf = (char*)uprv_malloc(fromLen +
1); |
| 317 if (fromBuf == NULL) { |
| 318 sts = U_MEMORY_ALLOCATION_ERROR; |
| 319 break; |
| 320 } |
| 321 const char* p = from; |
| 322 char* q = fromBuf; |
| 323 while (*p) { |
| 324 if (*p == ':') { |
| 325 *q++ = '/'; |
| 326 } else { |
| 327 *q++ = *p; |
| 328 } |
| 329 p++; |
| 330 } |
| 331 *q = 0; |
| 332 |
| 333 gKeyTypeStringPool->addElement(fromBuf, sts)
; |
| 334 if (U_FAILURE(sts)) { |
| 335 break; |
| 336 } |
| 337 from = fromBuf; |
| 338 } |
| 339 } |
| 340 uhash_put(typeDataMap, (void*)from, t, &sts); |
| 341 } |
| 342 } |
| 343 if (U_FAILURE(sts)) { |
| 344 break; |
| 345 } |
| 346 } |
| 347 |
| 348 if (bcpTypeAliasResByKey.isValid()) { |
| 349 LocalUResourceBundlePointer bcpTypeAliasDataEntry; |
| 350 |
| 351 ures_resetIterator(bcpTypeAliasResByKey.getAlias()); |
| 352 while (ures_hasNext(bcpTypeAliasResByKey.getAlias()) && U_SU
CCESS(sts)) { |
| 353 int32_t toLen; |
| 354 bcpTypeAliasDataEntry.adoptInstead(ures_getNextResource(
bcpTypeAliasResByKey.getAlias(), bcpTypeAliasDataEntry.orphan(), &sts)); |
| 355 const UChar* to = ures_getString(bcpTypeAliasDataEntry.g
etAlias(), &toLen, &sts); |
| 356 if (U_FAILURE(sts)) { |
| 357 break; |
| 358 } |
| 359 // check if this is an alias of bcp type |
| 360 if (uprv_compareInvAscii(NULL, bcpTypeId, -1, to, toLen)
== 0) { |
| 361 const char* from = ures_getKey(bcpTypeAliasDataEntry
.getAlias()); |
| 362 uhash_put(typeDataMap, (void*)from, t, &sts); |
| 363 } |
| 364 } |
| 365 if (U_FAILURE(sts)) { |
| 366 break; |
| 367 } |
| 368 } |
| 369 } |
| 370 } |
| 371 if (U_FAILURE(sts)) { |
| 372 break; |
| 373 } |
| 374 |
| 375 LocExtKeyData* keyData = (LocExtKeyData*)uprv_malloc(sizeof(LocExtKeyDat
a)); |
| 376 if (keyData == NULL) { |
| 377 sts = U_MEMORY_ALLOCATION_ERROR; |
| 378 break; |
| 379 } |
| 380 keyData->bcpId = bcpKeyId; |
| 381 keyData->legacyId = legacyKeyId; |
| 382 keyData->specialTypes = specialTypes; |
| 383 keyData->typeMap = typeDataMap; |
| 384 |
| 385 gLocExtKeyDataEntries->addElement((void*)keyData, sts); |
| 386 if (U_FAILURE(sts)) { |
| 387 break; |
| 388 } |
| 389 |
| 390 uhash_put(gLocExtKeyMap, (void*)legacyKeyId, keyData, &sts); |
| 391 if (legacyKeyId != bcpKeyId) { |
| 392 // different key value |
| 393 uhash_put(gLocExtKeyMap, (void*)bcpKeyId, keyData, &sts); |
| 394 } |
| 395 if (U_FAILURE(sts)) { |
| 396 break; |
| 397 } |
| 398 } |
| 399 } |
| 400 |
| 401 static UBool |
| 402 init() { |
| 403 UErrorCode sts = U_ZERO_ERROR; |
| 404 umtx_initOnce(gLocExtKeyMapInitOnce, &initFromResourceBundle, sts); |
| 405 if (U_FAILURE(sts)) { |
| 406 return FALSE; |
| 407 } |
| 408 return TRUE; |
| 409 } |
| 410 |
| 411 static UBool |
| 412 isSpecialTypeCodepoints(const char* val) { |
| 413 int32_t subtagLen = 0; |
| 414 const char* p = val; |
| 415 while (*p) { |
| 416 if (*p == '-') { |
| 417 if (subtagLen < 4 || subtagLen > 6) { |
| 418 return FALSE; |
| 419 } |
| 420 subtagLen = 0; |
| 421 } else if ((*p >= '0' && *p <= '9') || |
| 422 (*p >= 'A' && *p <= 'F') || // A-F/a-f are contiguous |
| 423 (*p >= 'a' && *p <= 'f')) { // also in EBCDIC |
| 424 subtagLen++; |
| 425 } else { |
| 426 return FALSE; |
| 427 } |
| 428 p++; |
| 429 } |
| 430 return (subtagLen >= 4 && subtagLen <= 6); |
| 431 } |
| 432 |
| 433 static UBool |
| 434 isSpecialTypeReorderCode(const char* val) { |
| 435 int32_t subtagLen = 0; |
| 436 const char* p = val; |
| 437 while (*p) { |
| 438 if (*p == '-') { |
| 439 if (subtagLen < 3 || subtagLen > 8) { |
| 440 return FALSE; |
| 441 } |
| 442 subtagLen = 0; |
| 443 } else if (uprv_isASCIILetter(*p)) { |
| 444 subtagLen++; |
| 445 } else { |
| 446 return FALSE; |
| 447 } |
| 448 p++; |
| 449 } |
| 450 return (subtagLen >=3 && subtagLen <=8); |
| 451 } |
| 452 |
| 453 U_CFUNC const char* |
| 454 ulocimp_toBcpKey(const char* key) { |
| 455 if (!init()) { |
| 456 return NULL; |
| 457 } |
| 458 |
| 459 LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
| 460 if (keyData != NULL) { |
| 461 return keyData->bcpId; |
| 462 } |
| 463 return NULL; |
| 464 } |
| 465 |
| 466 U_CFUNC const char* |
| 467 ulocimp_toLegacyKey(const char* key) { |
| 468 if (!init()) { |
| 469 return NULL; |
| 470 } |
| 471 |
| 472 LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
| 473 if (keyData != NULL) { |
| 474 return keyData->legacyId; |
| 475 } |
| 476 return NULL; |
| 477 } |
| 478 |
| 479 U_CFUNC const char* |
| 480 ulocimp_toBcpType(const char* key, const char* type, UBool* isKnownKey, UBool* i
sSpecialType) { |
| 481 if (isKnownKey != NULL) { |
| 482 *isKnownKey = FALSE; |
| 483 } |
| 484 if (isSpecialType != NULL) { |
| 485 *isSpecialType = FALSE; |
| 486 } |
| 487 |
| 488 if (!init()) { |
| 489 return NULL; |
| 490 } |
| 491 |
| 492 LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
| 493 if (keyData != NULL) { |
| 494 if (isKnownKey != NULL) { |
| 495 *isKnownKey = TRUE; |
| 496 } |
| 497 LocExtType* t = (LocExtType*)uhash_get(keyData->typeMap, type); |
| 498 if (t != NULL) { |
| 499 return t->bcpId; |
| 500 } |
| 501 if (keyData->specialTypes != SPECIALTYPE_NONE) { |
| 502 UBool matched = FALSE; |
| 503 if (keyData->specialTypes & SPECIALTYPE_CODEPOINTS) { |
| 504 matched = isSpecialTypeCodepoints(type); |
| 505 } |
| 506 if (!matched && keyData->specialTypes & SPECIALTYPE_REORDER_CODE) { |
| 507 matched = isSpecialTypeReorderCode(type); |
| 508 } |
| 509 if (matched) { |
| 510 if (isSpecialType != NULL) { |
| 511 *isSpecialType = TRUE; |
| 512 } |
| 513 return type; |
| 514 } |
| 515 } |
| 516 } |
| 517 return NULL; |
| 518 } |
| 519 |
| 520 |
| 521 U_CFUNC const char* |
| 522 ulocimp_toLegacyType(const char* key, const char* type, UBool* isKnownKey, UBool
* isSpecialType) { |
| 523 if (isKnownKey != NULL) { |
| 524 *isKnownKey = FALSE; |
| 525 } |
| 526 if (isSpecialType != NULL) { |
| 527 *isSpecialType = FALSE; |
| 528 } |
| 529 |
| 530 if (!init()) { |
| 531 return NULL; |
| 532 } |
| 533 |
| 534 LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
| 535 if (keyData != NULL) { |
| 536 if (isKnownKey != NULL) { |
| 537 *isKnownKey = TRUE; |
| 538 } |
| 539 LocExtType* t = (LocExtType*)uhash_get(keyData->typeMap, type); |
| 540 if (t != NULL) { |
| 541 return t->legacyId; |
| 542 } |
| 543 if (keyData->specialTypes != SPECIALTYPE_NONE) { |
| 544 UBool matched = FALSE; |
| 545 if (keyData->specialTypes & SPECIALTYPE_CODEPOINTS) { |
| 546 matched = isSpecialTypeCodepoints(type); |
| 547 } |
| 548 if (!matched && keyData->specialTypes & SPECIALTYPE_REORDER_CODE) { |
| 549 matched = isSpecialTypeReorderCode(type); |
| 550 } |
| 551 if (matched) { |
| 552 if (isSpecialType != NULL) { |
| 553 *isSpecialType = TRUE; |
| 554 } |
| 555 return type; |
| 556 } |
| 557 } |
| 558 } |
| 559 return NULL; |
| 560 } |
| 561 |
OLD | NEW |