Index: source/common/uloc_keytype.cpp |
diff --git a/source/common/uloc_keytype.cpp b/source/common/uloc_keytype.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..f8f1f1f35dcf036451eec300cc2ed6b81a479ba8 |
--- /dev/null |
+++ b/source/common/uloc_keytype.cpp |
@@ -0,0 +1,561 @@ |
+/* |
+********************************************************************** |
+* Copyright (C) 2014, International Business Machines |
+* Corporation and others. All Rights Reserved. |
+********************************************************************** |
+*/ |
+#include "unicode/utypes.h" |
+ |
+#include "cstring.h" |
+#include "uassert.h" |
+#include "ucln_cmn.h" |
+#include "uhash.h" |
+#include "umutex.h" |
+#include "uresimp.h" |
+#include "uvector.h" |
+ |
+static UHashtable* gLocExtKeyMap = NULL; |
+static icu::UInitOnce gLocExtKeyMapInitOnce = U_INITONCE_INITIALIZER; |
+static icu::UVector* gKeyTypeStringPool = NULL; |
+static icu::UVector* gLocExtKeyDataEntries = NULL; |
+static icu::UVector* gLocExtTypeEntries = NULL; |
+ |
+// bit flags for special types |
+typedef enum { |
+ SPECIALTYPE_NONE = 0, |
+ SPECIALTYPE_CODEPOINTS = 1, |
+ SPECIALTYPE_REORDER_CODE = 2 |
+} SpecialType; |
+ |
+typedef struct LocExtKeyData { |
+ const char* legacyId; |
+ const char* bcpId; |
+ UHashtable* typeMap; |
+ uint32_t specialTypes; |
+} LocExtKeyData; |
+ |
+typedef struct LocExtType { |
+ const char* legacyId; |
+ const char* bcpId; |
+} LocExtType; |
+ |
+U_CDECL_BEGIN |
+ |
+static UBool U_CALLCONV |
+uloc_key_type_cleanup(void) { |
+ if (gLocExtKeyMap != NULL) { |
+ uhash_close(gLocExtKeyMap); |
+ gLocExtKeyMap = NULL; |
+ } |
+ |
+ delete gLocExtKeyDataEntries; |
+ gLocExtKeyDataEntries = NULL; |
+ |
+ delete gLocExtTypeEntries; |
+ gLocExtTypeEntries = NULL; |
+ |
+ delete gKeyTypeStringPool; |
+ gKeyTypeStringPool = NULL; |
+ |
+ gLocExtKeyMapInitOnce.reset(); |
+ return TRUE; |
+} |
+ |
+static void U_CALLCONV |
+uloc_deleteKeyTypeStringPoolEntry(void* obj) { |
+ uprv_free(obj); |
+} |
+ |
+static void U_CALLCONV |
+uloc_deleteKeyDataEntry(void* obj) { |
+ LocExtKeyData* keyData = (LocExtKeyData*)obj; |
+ if (keyData->typeMap != NULL) { |
+ uhash_close(keyData->typeMap); |
+ } |
+ uprv_free(keyData); |
+} |
+ |
+static void U_CALLCONV |
+uloc_deleteTypeEntry(void* obj) { |
+ uprv_free(obj); |
+} |
+ |
+U_CDECL_END |
+ |
+ |
+static void U_CALLCONV |
+initFromResourceBundle(UErrorCode& sts) { |
+ U_NAMESPACE_USE |
+ ucln_common_registerCleanup(UCLN_COMMON_LOCALE_KEY_TYPE, uloc_key_type_cleanup); |
+ |
+ gLocExtKeyMap = uhash_open(uhash_hashIChars, uhash_compareIChars, NULL, &sts); |
+ |
+ LocalUResourceBundlePointer keyTypeDataRes(ures_openDirect(NULL, "keyTypeData", &sts)); |
+ LocalUResourceBundlePointer keyMapRes(ures_getByKey(keyTypeDataRes.getAlias(), "keyMap", NULL, &sts)); |
+ LocalUResourceBundlePointer typeMapRes(ures_getByKey(keyTypeDataRes.getAlias(), "typeMap", NULL, &sts)); |
+ |
+ if (U_FAILURE(sts)) { |
+ return; |
+ } |
+ |
+ UErrorCode tmpSts = U_ZERO_ERROR; |
+ LocalUResourceBundlePointer typeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "typeAlias", NULL, &tmpSts)); |
+ tmpSts = U_ZERO_ERROR; |
+ LocalUResourceBundlePointer bcpTypeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "bcpTypeAlias", NULL, &tmpSts)); |
+ |
+ // initialize vectors storing dynamically allocated objects |
+ gKeyTypeStringPool = new UVector(uloc_deleteKeyTypeStringPoolEntry, NULL, sts); |
+ if (gKeyTypeStringPool == NULL) { |
+ if (U_SUCCESS(sts)) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ } |
+ } |
+ if (U_FAILURE(sts)) { |
+ return; |
+ } |
+ gLocExtKeyDataEntries = new UVector(uloc_deleteKeyDataEntry, NULL, sts); |
+ if (gLocExtKeyDataEntries == NULL) { |
+ if (U_SUCCESS(sts)) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ } |
+ } |
+ if (U_FAILURE(sts)) { |
+ return; |
+ } |
+ gLocExtTypeEntries = new UVector(uloc_deleteTypeEntry, NULL, sts); |
+ if (gLocExtTypeEntries == NULL) { |
+ if (U_SUCCESS(sts)) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ } |
+ } |
+ if (U_FAILURE(sts)) { |
+ return; |
+ } |
+ |
+ // iterate through keyMap resource |
+ LocalUResourceBundlePointer keyMapEntry; |
+ |
+ while (ures_hasNext(keyMapRes.getAlias())) { |
+ keyMapEntry.adoptInstead(ures_getNextResource(keyMapRes.getAlias(), keyMapEntry.orphan(), &sts)); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ const char* legacyKeyId = ures_getKey(keyMapEntry.getAlias()); |
+ int32_t bcpKeyIdLen = 0; |
+ const UChar* uBcpKeyId = ures_getString(keyMapEntry.getAlias(), &bcpKeyIdLen, &sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ |
+ // empty value indicates that BCP key is same with the legacy key. |
+ const char* bcpKeyId = legacyKeyId; |
+ if (bcpKeyIdLen > 0) { |
+ char* bcpKeyIdBuf = (char*)uprv_malloc(bcpKeyIdLen + 1); |
+ if (bcpKeyIdBuf == NULL) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ break; |
+ } |
+ u_UCharsToChars(uBcpKeyId, bcpKeyIdBuf, bcpKeyIdLen); |
+ bcpKeyIdBuf[bcpKeyIdLen] = 0; |
+ gKeyTypeStringPool->addElement(bcpKeyIdBuf, sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ bcpKeyId = bcpKeyIdBuf; |
+ } |
+ |
+ UBool isTZ = uprv_strcmp(legacyKeyId, "timezone") == 0; |
+ |
+ UHashtable* typeDataMap = uhash_open(uhash_hashIChars, uhash_compareIChars, NULL, &sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ uint32_t specialTypes = SPECIALTYPE_NONE; |
+ |
+ LocalUResourceBundlePointer typeAliasResByKey; |
+ LocalUResourceBundlePointer bcpTypeAliasResByKey; |
+ |
+ if (typeAliasRes.isValid()) { |
+ tmpSts = U_ZERO_ERROR; |
+ typeAliasResByKey.adoptInstead(ures_getByKey(typeAliasRes.getAlias(), legacyKeyId, NULL, &tmpSts)); |
+ if (U_FAILURE(tmpSts)) { |
+ typeAliasResByKey.orphan(); |
+ } |
+ } |
+ if (bcpTypeAliasRes.isValid()) { |
+ tmpSts = U_ZERO_ERROR; |
+ bcpTypeAliasResByKey.adoptInstead(ures_getByKey(bcpTypeAliasRes.getAlias(), bcpKeyId, NULL, &tmpSts)); |
+ if (U_FAILURE(tmpSts)) { |
+ bcpTypeAliasResByKey.orphan(); |
+ } |
+ } |
+ |
+ // look up type map for the key, and walk through the mapping data |
+ tmpSts = U_ZERO_ERROR; |
+ LocalUResourceBundlePointer typeMapResByKey(ures_getByKey(typeMapRes.getAlias(), legacyKeyId, NULL, &tmpSts)); |
+ if (U_FAILURE(tmpSts)) { |
+ // type map for each key must exist |
+ U_ASSERT(FALSE); |
+ } else { |
+ LocalUResourceBundlePointer typeMapEntry; |
+ |
+ while (ures_hasNext(typeMapResByKey.getAlias())) { |
+ typeMapEntry.adoptInstead(ures_getNextResource(typeMapResByKey.getAlias(), typeMapEntry.orphan(), &sts)); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ const char* legacyTypeId = ures_getKey(typeMapEntry.getAlias()); |
+ |
+ // special types |
+ if (uprv_strcmp(legacyTypeId, "CODEPOINTS") == 0) { |
+ specialTypes |= SPECIALTYPE_CODEPOINTS; |
+ continue; |
+ } |
+ if (uprv_strcmp(legacyTypeId, "REORDER_CODE") == 0) { |
+ specialTypes |= SPECIALTYPE_REORDER_CODE; |
+ continue; |
+ } |
+ |
+ if (isTZ) { |
+ // a timezone key uses a colon instead of a slash in the resource. |
+ // e.g. America:Los_Angeles |
+ if (uprv_strchr(legacyTypeId, ':') != NULL) { |
+ int32_t legacyTypeIdLen = uprv_strlen(legacyTypeId); |
+ char* legacyTypeIdBuf = (char*)uprv_malloc(legacyTypeIdLen + 1); |
+ if (legacyTypeIdBuf == NULL) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ break; |
+ } |
+ const char* p = legacyTypeId; |
+ char* q = legacyTypeIdBuf; |
+ while (*p) { |
+ if (*p == ':') { |
+ *q++ = '/'; |
+ } else { |
+ *q++ = *p; |
+ } |
+ p++; |
+ } |
+ *q = 0; |
+ |
+ gKeyTypeStringPool->addElement(legacyTypeIdBuf, sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ legacyTypeId = legacyTypeIdBuf; |
+ } |
+ } |
+ |
+ int32_t bcpTypeIdLen = 0; |
+ const UChar* uBcpTypeId = ures_getString(typeMapEntry.getAlias(), &bcpTypeIdLen, &sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ |
+ // empty value indicates that BCP type is same with the legacy type. |
+ const char* bcpTypeId = legacyTypeId; |
+ if (bcpTypeIdLen > 0) { |
+ char* bcpTypeIdBuf = (char*)uprv_malloc(bcpTypeIdLen + 1); |
+ if (bcpTypeIdBuf == NULL) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ break; |
+ } |
+ u_UCharsToChars(uBcpTypeId, bcpTypeIdBuf, bcpTypeIdLen); |
+ bcpTypeIdBuf[bcpTypeIdLen] = 0; |
+ gKeyTypeStringPool->addElement(bcpTypeIdBuf, sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ bcpTypeId = bcpTypeIdBuf; |
+ } |
+ |
+ // Note: legacy type value should never be |
+ // equivalent to bcp type value of a different |
+ // type under the same key. So we use a single |
+ // map for lookup. |
+ LocExtType* t = (LocExtType*)uprv_malloc(sizeof(LocExtType)); |
+ if (t == NULL) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ break; |
+ } |
+ t->bcpId = bcpTypeId; |
+ t->legacyId = legacyTypeId; |
+ gLocExtTypeEntries->addElement((void*)t, sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ |
+ uhash_put(typeDataMap, (void*)legacyTypeId, t, &sts); |
+ if (bcpTypeId != legacyTypeId) { |
+ // different type value |
+ uhash_put(typeDataMap, (void*)bcpTypeId, t, &sts); |
+ } |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ |
+ // also put aliases in the map |
+ if (typeAliasResByKey.isValid()) { |
+ LocalUResourceBundlePointer typeAliasDataEntry; |
+ |
+ ures_resetIterator(typeAliasResByKey.getAlias()); |
+ while (ures_hasNext(typeAliasResByKey.getAlias()) && U_SUCCESS(sts)) { |
+ int32_t toLen; |
+ typeAliasDataEntry.adoptInstead(ures_getNextResource(typeAliasResByKey.getAlias(), typeAliasDataEntry.orphan(), &sts)); |
+ const UChar* to = ures_getString(typeAliasDataEntry.getAlias(), &toLen, &sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ // check if this is an alias of canoncal legacy type |
+ if (uprv_compareInvAscii(NULL, legacyTypeId, -1, to, toLen) == 0) { |
+ const char* from = ures_getKey(typeAliasDataEntry.getAlias()); |
+ if (isTZ) { |
+ // replace colon with slash if necessary |
+ if (uprv_strchr(from, ':') != NULL) { |
+ int32_t fromLen = uprv_strlen(from); |
+ char* fromBuf = (char*)uprv_malloc(fromLen + 1); |
+ if (fromBuf == NULL) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ break; |
+ } |
+ const char* p = from; |
+ char* q = fromBuf; |
+ while (*p) { |
+ if (*p == ':') { |
+ *q++ = '/'; |
+ } else { |
+ *q++ = *p; |
+ } |
+ p++; |
+ } |
+ *q = 0; |
+ |
+ gKeyTypeStringPool->addElement(fromBuf, sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ from = fromBuf; |
+ } |
+ } |
+ uhash_put(typeDataMap, (void*)from, t, &sts); |
+ } |
+ } |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ } |
+ |
+ if (bcpTypeAliasResByKey.isValid()) { |
+ LocalUResourceBundlePointer bcpTypeAliasDataEntry; |
+ |
+ ures_resetIterator(bcpTypeAliasResByKey.getAlias()); |
+ while (ures_hasNext(bcpTypeAliasResByKey.getAlias()) && U_SUCCESS(sts)) { |
+ int32_t toLen; |
+ bcpTypeAliasDataEntry.adoptInstead(ures_getNextResource(bcpTypeAliasResByKey.getAlias(), bcpTypeAliasDataEntry.orphan(), &sts)); |
+ const UChar* to = ures_getString(bcpTypeAliasDataEntry.getAlias(), &toLen, &sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ // check if this is an alias of bcp type |
+ if (uprv_compareInvAscii(NULL, bcpTypeId, -1, to, toLen) == 0) { |
+ const char* from = ures_getKey(bcpTypeAliasDataEntry.getAlias()); |
+ uhash_put(typeDataMap, (void*)from, t, &sts); |
+ } |
+ } |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ } |
+ } |
+ } |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ |
+ LocExtKeyData* keyData = (LocExtKeyData*)uprv_malloc(sizeof(LocExtKeyData)); |
+ if (keyData == NULL) { |
+ sts = U_MEMORY_ALLOCATION_ERROR; |
+ break; |
+ } |
+ keyData->bcpId = bcpKeyId; |
+ keyData->legacyId = legacyKeyId; |
+ keyData->specialTypes = specialTypes; |
+ keyData->typeMap = typeDataMap; |
+ |
+ gLocExtKeyDataEntries->addElement((void*)keyData, sts); |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ |
+ uhash_put(gLocExtKeyMap, (void*)legacyKeyId, keyData, &sts); |
+ if (legacyKeyId != bcpKeyId) { |
+ // different key value |
+ uhash_put(gLocExtKeyMap, (void*)bcpKeyId, keyData, &sts); |
+ } |
+ if (U_FAILURE(sts)) { |
+ break; |
+ } |
+ } |
+} |
+ |
+static UBool |
+init() { |
+ UErrorCode sts = U_ZERO_ERROR; |
+ umtx_initOnce(gLocExtKeyMapInitOnce, &initFromResourceBundle, sts); |
+ if (U_FAILURE(sts)) { |
+ return FALSE; |
+ } |
+ return TRUE; |
+} |
+ |
+static UBool |
+isSpecialTypeCodepoints(const char* val) { |
+ int32_t subtagLen = 0; |
+ const char* p = val; |
+ while (*p) { |
+ if (*p == '-') { |
+ if (subtagLen < 4 || subtagLen > 6) { |
+ return FALSE; |
+ } |
+ subtagLen = 0; |
+ } else if ((*p >= '0' && *p <= '9') || |
+ (*p >= 'A' && *p <= 'F') || // A-F/a-f are contiguous |
+ (*p >= 'a' && *p <= 'f')) { // also in EBCDIC |
+ subtagLen++; |
+ } else { |
+ return FALSE; |
+ } |
+ p++; |
+ } |
+ return (subtagLen >= 4 && subtagLen <= 6); |
+} |
+ |
+static UBool |
+isSpecialTypeReorderCode(const char* val) { |
+ int32_t subtagLen = 0; |
+ const char* p = val; |
+ while (*p) { |
+ if (*p == '-') { |
+ if (subtagLen < 3 || subtagLen > 8) { |
+ return FALSE; |
+ } |
+ subtagLen = 0; |
+ } else if (uprv_isASCIILetter(*p)) { |
+ subtagLen++; |
+ } else { |
+ return FALSE; |
+ } |
+ p++; |
+ } |
+ return (subtagLen >=3 && subtagLen <=8); |
+} |
+ |
+U_CFUNC const char* |
+ulocimp_toBcpKey(const char* key) { |
+ if (!init()) { |
+ return NULL; |
+ } |
+ |
+ LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
+ if (keyData != NULL) { |
+ return keyData->bcpId; |
+ } |
+ return NULL; |
+} |
+ |
+U_CFUNC const char* |
+ulocimp_toLegacyKey(const char* key) { |
+ if (!init()) { |
+ return NULL; |
+ } |
+ |
+ LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
+ if (keyData != NULL) { |
+ return keyData->legacyId; |
+ } |
+ return NULL; |
+} |
+ |
+U_CFUNC const char* |
+ulocimp_toBcpType(const char* key, const char* type, UBool* isKnownKey, UBool* isSpecialType) { |
+ if (isKnownKey != NULL) { |
+ *isKnownKey = FALSE; |
+ } |
+ if (isSpecialType != NULL) { |
+ *isSpecialType = FALSE; |
+ } |
+ |
+ if (!init()) { |
+ return NULL; |
+ } |
+ |
+ LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
+ if (keyData != NULL) { |
+ if (isKnownKey != NULL) { |
+ *isKnownKey = TRUE; |
+ } |
+ LocExtType* t = (LocExtType*)uhash_get(keyData->typeMap, type); |
+ if (t != NULL) { |
+ return t->bcpId; |
+ } |
+ if (keyData->specialTypes != SPECIALTYPE_NONE) { |
+ UBool matched = FALSE; |
+ if (keyData->specialTypes & SPECIALTYPE_CODEPOINTS) { |
+ matched = isSpecialTypeCodepoints(type); |
+ } |
+ if (!matched && keyData->specialTypes & SPECIALTYPE_REORDER_CODE) { |
+ matched = isSpecialTypeReorderCode(type); |
+ } |
+ if (matched) { |
+ if (isSpecialType != NULL) { |
+ *isSpecialType = TRUE; |
+ } |
+ return type; |
+ } |
+ } |
+ } |
+ return NULL; |
+} |
+ |
+ |
+U_CFUNC const char* |
+ulocimp_toLegacyType(const char* key, const char* type, UBool* isKnownKey, UBool* isSpecialType) { |
+ if (isKnownKey != NULL) { |
+ *isKnownKey = FALSE; |
+ } |
+ if (isSpecialType != NULL) { |
+ *isSpecialType = FALSE; |
+ } |
+ |
+ if (!init()) { |
+ return NULL; |
+ } |
+ |
+ LocExtKeyData* keyData = (LocExtKeyData*)uhash_get(gLocExtKeyMap, key); |
+ if (keyData != NULL) { |
+ if (isKnownKey != NULL) { |
+ *isKnownKey = TRUE; |
+ } |
+ LocExtType* t = (LocExtType*)uhash_get(keyData->typeMap, type); |
+ if (t != NULL) { |
+ return t->legacyId; |
+ } |
+ if (keyData->specialTypes != SPECIALTYPE_NONE) { |
+ UBool matched = FALSE; |
+ if (keyData->specialTypes & SPECIALTYPE_CODEPOINTS) { |
+ matched = isSpecialTypeCodepoints(type); |
+ } |
+ if (!matched && keyData->specialTypes & SPECIALTYPE_REORDER_CODE) { |
+ matched = isSpecialTypeReorderCode(type); |
+ } |
+ if (matched) { |
+ if (isSpecialType != NULL) { |
+ *isSpecialType = TRUE; |
+ } |
+ return type; |
+ } |
+ } |
+ } |
+ return NULL; |
+} |
+ |