[apple/icu.git] / icuSources / common / uloc_keytype.cpp

/*
**********************************************************************
*   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;
}
Commit	Line	Data
b331163b A	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_cleanup);
90
91	gLocExtKeyMap = uhash_open(uhash_hashIChars, uhash_compareIChars, NULL, &sts);
92
93	LocalUResourceBundlePointer keyTypeDataRes(ures_openDirect(NULL, "keyTypeData", &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.getAlias(), "typeAlias", NULL, &tmpSts));
103	tmpSts = U_ZERO_ERROR;
104	LocalUResourceBundlePointer bcpTypeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "bcpTypeAlias", NULL, &tmpSts));
105
106	// initialize vectors storing dynamically allocated objects
107	gKeyTypeStringPool = new UVector(uloc_deleteKeyTypeStringPoolEntry, NULL, sts);
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(), keyMapEntry.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(), &bcpKeyIdLen, &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_compareIChars, 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.getAlias(), 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.getAlias(), 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.getAlias(), 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 resource.
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(legacyTypeIdLen + 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 type.
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_SUCCESS(sts)) {
303	int32_t toLen;
304	typeAliasDataEntry.adoptInstead(ures_getNextResource(typeAliasResByKey.getAlias(), typeAliasDataEntry.orphan(), &sts));
305	const UChar* to = ures_getString(typeAliasDataEntry.getAlias(), &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, toLen) == 0) {
311	const char* from = ures_getKey(typeAliasDataEntry.getAlias());
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_SUCCESS(sts)) {
353	int32_t toLen;
354	bcpTypeAliasDataEntry.adoptInstead(ures_getNextResource(bcpTypeAliasResByKey.getAlias(), bcpTypeAliasDataEntry.orphan(), &sts));
355	const UChar* to = ures_getString(bcpTypeAliasDataEntry.getAlias(), &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(LocExtKeyData));
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* isSpecialType) {
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