diff options
Diffstat (limited to 'deps/icu-small/source/common/uloc_tag.c')
-rw-r--r-- | deps/icu-small/source/common/uloc_tag.c | 2509 |
1 files changed, 2509 insertions, 0 deletions
diff --git a/deps/icu-small/source/common/uloc_tag.c b/deps/icu-small/source/common/uloc_tag.c new file mode 100644 index 0000000000..3167e0e67e --- /dev/null +++ b/deps/icu-small/source/common/uloc_tag.c @@ -0,0 +1,2509 @@ +/* +********************************************************************** +* Copyright (C) 2009-2015, International Business Machines +* Corporation and others. All Rights Reserved. +********************************************************************** +*/ + +#include "unicode/utypes.h" +#include "unicode/ures.h" +#include "unicode/putil.h" +#include "unicode/uloc.h" +#include "ustr_imp.h" +#include "cmemory.h" +#include "cstring.h" +#include "putilimp.h" +#include "uinvchar.h" +#include "ulocimp.h" +#include "uassert.h" + +/* struct holding a single variant */ +typedef struct VariantListEntry { + const char *variant; + struct VariantListEntry *next; +} VariantListEntry; + +/* struct holding a single attribute value */ +typedef struct AttributeListEntry { + const char *attribute; + struct AttributeListEntry *next; +} AttributeListEntry; + +/* struct holding a single extension */ +typedef struct ExtensionListEntry { + const char *key; + const char *value; + struct ExtensionListEntry *next; +} ExtensionListEntry; + +#define MAXEXTLANG 3 +typedef struct ULanguageTag { + char *buf; /* holding parsed subtags */ + const char *language; + const char *extlang[MAXEXTLANG]; + const char *script; + const char *region; + VariantListEntry *variants; + ExtensionListEntry *extensions; + const char *privateuse; + const char *grandfathered; +} ULanguageTag; + +#define MINLEN 2 +#define SEP '-' +#define PRIVATEUSE 'x' +#define LDMLEXT 'u' + +#define LOCALE_SEP '_' +#define LOCALE_EXT_SEP '@' +#define LOCALE_KEYWORD_SEP ';' +#define LOCALE_KEY_TYPE_SEP '=' + +#define ISALPHA(c) uprv_isASCIILetter(c) +#define ISNUMERIC(c) ((c)>='0' && (c)<='9') + +static const char EMPTY[] = ""; +static const char LANG_UND[] = "und"; +static const char PRIVATEUSE_KEY[] = "x"; +static const char _POSIX[] = "_POSIX"; +static const char POSIX_KEY[] = "va"; +static const char POSIX_VALUE[] = "posix"; +static const char LOCALE_ATTRIBUTE_KEY[] = "attribute"; +static const char PRIVUSE_VARIANT_PREFIX[] = "lvariant"; +static const char LOCALE_TYPE_YES[] = "yes"; + +#define LANG_UND_LEN 3 + +static const char* const GRANDFATHERED[] = { +/* grandfathered preferred */ + "art-lojban", "jbo", + "cel-gaulish", "xtg-x-cel-gaulish", + "en-GB-oed", "en-GB-x-oed", + "i-ami", "ami", + "i-bnn", "bnn", + "i-default", "en-x-i-default", + "i-enochian", "und-x-i-enochian", + "i-hak", "hak", + "i-klingon", "tlh", + "i-lux", "lb", + "i-mingo", "see-x-i-mingo", + "i-navajo", "nv", + "i-pwn", "pwn", + "i-tao", "tao", + "i-tay", "tay", + "i-tsu", "tsu", + "no-bok", "nb", + "no-nyn", "nn", + "sgn-be-fr", "sfb", + "sgn-be-nl", "vgt", + "sgn-ch-de", "sgg", + "zh-guoyu", "cmn", + "zh-hakka", "hak", + "zh-min", "nan-x-zh-min", + "zh-min-nan", "nan", + "zh-xiang", "hsn", + NULL, NULL +}; + +static const char DEPRECATEDLANGS[][4] = { +/* deprecated new */ + "iw", "he", + "ji", "yi", + "in", "id" +}; + +/* +* ------------------------------------------------- +* +* These ultag_ functions may be exposed as APIs later +* +* ------------------------------------------------- +*/ + +static ULanguageTag* +ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* status); + +static void +ultag_close(ULanguageTag* langtag); + +static const char* +ultag_getLanguage(const ULanguageTag* langtag); + +#if 0 +static const char* +ultag_getJDKLanguage(const ULanguageTag* langtag); +#endif + +static const char* +ultag_getExtlang(const ULanguageTag* langtag, int32_t idx); + +static int32_t +ultag_getExtlangSize(const ULanguageTag* langtag); + +static const char* +ultag_getScript(const ULanguageTag* langtag); + +static const char* +ultag_getRegion(const ULanguageTag* langtag); + +static const char* +ultag_getVariant(const ULanguageTag* langtag, int32_t idx); + +static int32_t +ultag_getVariantsSize(const ULanguageTag* langtag); + +static const char* +ultag_getExtensionKey(const ULanguageTag* langtag, int32_t idx); + +static const char* +ultag_getExtensionValue(const ULanguageTag* langtag, int32_t idx); + +static int32_t +ultag_getExtensionsSize(const ULanguageTag* langtag); + +static const char* +ultag_getPrivateUse(const ULanguageTag* langtag); + +#if 0 +static const char* +ultag_getGrandfathered(const ULanguageTag* langtag); +#endif + +/* +* ------------------------------------------------- +* +* Language subtag syntax validation functions +* +* ------------------------------------------------- +*/ + +static UBool +_isAlphaString(const char* s, int32_t len) { + int32_t i; + for (i = 0; i < len; i++) { + if (!ISALPHA(*(s + i))) { + return FALSE; + } + } + return TRUE; +} + +static UBool +_isNumericString(const char* s, int32_t len) { + int32_t i; + for (i = 0; i < len; i++) { + if (!ISNUMERIC(*(s + i))) { + return FALSE; + } + } + return TRUE; +} + +static UBool +_isAlphaNumericString(const char* s, int32_t len) { + int32_t i; + for (i = 0; i < len; i++) { + if (!ISALPHA(*(s + i)) && !ISNUMERIC(*(s + i))) { + return FALSE; + } + } + return TRUE; +} + +static UBool +_isLanguageSubtag(const char* s, int32_t len) { + /* + * language = 2*3ALPHA ; shortest ISO 639 code + * ["-" extlang] ; sometimes followed by + * ; extended language subtags + * / 4ALPHA ; or reserved for future use + * / 5*8ALPHA ; or registered language subtag + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len >= 2 && len <= 8 && _isAlphaString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isExtlangSubtag(const char* s, int32_t len) { + /* + * extlang = 3ALPHA ; selected ISO 639 codes + * *2("-" 3ALPHA) ; permanently reserved + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len == 3 && _isAlphaString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isScriptSubtag(const char* s, int32_t len) { + /* + * script = 4ALPHA ; ISO 15924 code + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len == 4 && _isAlphaString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isRegionSubtag(const char* s, int32_t len) { + /* + * region = 2ALPHA ; ISO 3166-1 code + * / 3DIGIT ; UN M.49 code + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len == 2 && _isAlphaString(s, len)) { + return TRUE; + } + if (len == 3 && _isNumericString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isVariantSubtag(const char* s, int32_t len) { + /* + * variant = 5*8alphanum ; registered variants + * / (DIGIT 3alphanum) + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len >= 5 && len <= 8 && _isAlphaNumericString(s, len)) { + return TRUE; + } + if (len == 4 && ISNUMERIC(*s) && _isAlphaNumericString(s + 1, 3)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isPrivateuseVariantSubtag(const char* s, int32_t len) { + /* + * variant = 1*8alphanum ; registered variants + * / (DIGIT 3alphanum) + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len >= 1 && len <= 8 && _isAlphaNumericString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isExtensionSingleton(const char* s, int32_t len) { + /* + * extension = singleton 1*("-" (2*8alphanum)) + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len == 1 && ISALPHA(*s) && (uprv_tolower(*s) != PRIVATEUSE)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isExtensionSubtag(const char* s, int32_t len) { + /* + * extension = singleton 1*("-" (2*8alphanum)) + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len >= 2 && len <= 8 && _isAlphaNumericString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isExtensionSubtags(const char* s, int32_t len) { + const char *p = s; + const char *pSubtag = NULL; + + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + + while ((p - s) < len) { + if (*p == SEP) { + if (pSubtag == NULL) { + return FALSE; + } + if (!_isExtensionSubtag(pSubtag, (int32_t)(p - pSubtag))) { + return FALSE; + } + pSubtag = NULL; + } else if (pSubtag == NULL) { + pSubtag = p; + } + p++; + } + if (pSubtag == NULL) { + return FALSE; + } + return _isExtensionSubtag(pSubtag, (int32_t)(p - pSubtag)); +} + +static UBool +_isPrivateuseValueSubtag(const char* s, int32_t len) { + /* + * privateuse = "x" 1*("-" (1*8alphanum)) + */ + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len >= 1 && len <= 8 && _isAlphaNumericString(s, len)) { + return TRUE; + } + return FALSE; +} + +static UBool +_isPrivateuseValueSubtags(const char* s, int32_t len) { + const char *p = s; + const char *pSubtag = NULL; + + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + + while ((p - s) < len) { + if (*p == SEP) { + if (pSubtag == NULL) { + return FALSE; + } + if (!_isPrivateuseValueSubtag(pSubtag, (int32_t)(p - pSubtag))) { + return FALSE; + } + pSubtag = NULL; + } else if (pSubtag == NULL) { + pSubtag = p; + } + p++; + } + if (pSubtag == NULL) { + return FALSE; + } + return _isPrivateuseValueSubtag(pSubtag, (int32_t)(p - pSubtag)); +} + +U_CFUNC UBool +ultag_isUnicodeLocaleKey(const char* s, int32_t len) { + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + if (len == 2 && _isAlphaNumericString(s, len)) { + return TRUE; + } + return FALSE; +} + +U_CFUNC UBool +ultag_isUnicodeLocaleType(const char*s, int32_t len) { + const char* p; + int32_t subtagLen = 0; + + if (len < 0) { + len = (int32_t)uprv_strlen(s); + } + + for (p = s; len > 0; p++, len--) { + if (*p == SEP) { + if (subtagLen < 3) { + return FALSE; + } + subtagLen = 0; + } else if (ISALPHA(*p) || ISNUMERIC(*p)) { + subtagLen++; + if (subtagLen > 8) { + return FALSE; + } + } else { + return FALSE; + } + } + + return (subtagLen >= 3); +} +/* +* ------------------------------------------------- +* +* Helper functions +* +* ------------------------------------------------- +*/ + +static UBool +_addVariantToList(VariantListEntry **first, VariantListEntry *var) { + UBool bAdded = TRUE; + + if (*first == NULL) { + var->next = NULL; + *first = var; + } else { + VariantListEntry *prev, *cur; + int32_t cmp; + + /* variants order should be preserved */ + prev = NULL; + cur = *first; + while (TRUE) { + if (cur == NULL) { + prev->next = var; + var->next = NULL; + break; + } + + /* Checking for duplicate variant */ + cmp = uprv_compareInvCharsAsAscii(var->variant, cur->variant); + if (cmp == 0) { + /* duplicated variant */ + bAdded = FALSE; + break; + } + prev = cur; + cur = cur->next; + } + } + + return bAdded; +} + +static UBool +_addAttributeToList(AttributeListEntry **first, AttributeListEntry *attr) { + UBool bAdded = TRUE; + + if (*first == NULL) { + attr->next = NULL; + *first = attr; + } else { + AttributeListEntry *prev, *cur; + int32_t cmp; + + /* reorder variants in alphabetical order */ + prev = NULL; + cur = *first; + while (TRUE) { + if (cur == NULL) { + prev->next = attr; + attr->next = NULL; + break; + } + cmp = uprv_compareInvCharsAsAscii(attr->attribute, cur->attribute); + if (cmp < 0) { + if (prev == NULL) { + *first = attr; + } else { + prev->next = attr; + } + attr->next = cur; + break; + } + if (cmp == 0) { + /* duplicated variant */ + bAdded = FALSE; + break; + } + prev = cur; + cur = cur->next; + } + } + + return bAdded; +} + + +static UBool +_addExtensionToList(ExtensionListEntry **first, ExtensionListEntry *ext, UBool localeToBCP) { + UBool bAdded = TRUE; + + if (*first == NULL) { + ext->next = NULL; + *first = ext; + } else { + ExtensionListEntry *prev, *cur; + int32_t cmp; + + /* reorder variants in alphabetical order */ + prev = NULL; + cur = *first; + while (TRUE) { + if (cur == NULL) { + prev->next = ext; + ext->next = NULL; + break; + } + if (localeToBCP) { + /* special handling for locale to bcp conversion */ + int32_t len, curlen; + + len = (int32_t)uprv_strlen(ext->key); + curlen = (int32_t)uprv_strlen(cur->key); + + if (len == 1 && curlen == 1) { + if (*(ext->key) == *(cur->key)) { + cmp = 0; + } else if (*(ext->key) == PRIVATEUSE) { + cmp = 1; + } else if (*(cur->key) == PRIVATEUSE) { + cmp = -1; + } else { + cmp = *(ext->key) - *(cur->key); + } + } else if (len == 1) { + cmp = *(ext->key) - LDMLEXT; + } else if (curlen == 1) { + cmp = LDMLEXT - *(cur->key); + } else { + cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); + } + } else { + cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); + } + if (cmp < 0) { + if (prev == NULL) { + *first = ext; + } else { + prev->next = ext; + } + ext->next = cur; + break; + } + if (cmp == 0) { + /* duplicated extension key */ + bAdded = FALSE; + break; + } + prev = cur; + cur = cur->next; + } + } + + return bAdded; +} + +static void +_initializeULanguageTag(ULanguageTag* langtag) { + int32_t i; + + langtag->buf = NULL; + + langtag->language = EMPTY; + for (i = 0; i < MAXEXTLANG; i++) { + langtag->extlang[i] = NULL; + } + + langtag->script = EMPTY; + langtag->region = EMPTY; + + langtag->variants = NULL; + langtag->extensions = NULL; + + langtag->grandfathered = EMPTY; + langtag->privateuse = EMPTY; +} + +static int32_t +_appendLanguageToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UErrorCode* status) { + char buf[ULOC_LANG_CAPACITY]; + UErrorCode tmpStatus = U_ZERO_ERROR; + int32_t len, i; + int32_t reslen = 0; + + if (U_FAILURE(*status)) { + return 0; + } + + len = uloc_getLanguage(localeID, buf, sizeof(buf), &tmpStatus); + if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + len = 0; + } + + /* Note: returned language code is in lower case letters */ + + if (len == 0) { + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, LANG_UND, uprv_min(LANG_UND_LEN, capacity - reslen)); + } + reslen += LANG_UND_LEN; + } else if (!_isLanguageSubtag(buf, len)) { + /* invalid language code */ + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, LANG_UND, uprv_min(LANG_UND_LEN, capacity - reslen)); + } + reslen += LANG_UND_LEN; + } else { + /* resolve deprecated */ + for (i = 0; i < UPRV_LENGTHOF(DEPRECATEDLANGS); i += 2) { + if (uprv_compareInvCharsAsAscii(buf, DEPRECATEDLANGS[i]) == 0) { + uprv_strcpy(buf, DEPRECATEDLANGS[i + 1]); + len = (int32_t)uprv_strlen(buf); + break; + } + } + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, buf, uprv_min(len, capacity - reslen)); + } + reslen += len; + } + u_terminateChars(appendAt, capacity, reslen, status); + return reslen; +} + +static int32_t +_appendScriptToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UErrorCode* status) { + char buf[ULOC_SCRIPT_CAPACITY]; + UErrorCode tmpStatus = U_ZERO_ERROR; + int32_t len; + int32_t reslen = 0; + + if (U_FAILURE(*status)) { + return 0; + } + + len = uloc_getScript(localeID, buf, sizeof(buf), &tmpStatus); + if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + return 0; + } + + if (len > 0) { + if (!_isScriptSubtag(buf, len)) { + /* invalid script code */ + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + return 0; + } else { + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, buf, uprv_min(len, capacity - reslen)); + } + reslen += len; + } + } + u_terminateChars(appendAt, capacity, reslen, status); + return reslen; +} + +static int32_t +_appendRegionToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UErrorCode* status) { + char buf[ULOC_COUNTRY_CAPACITY]; + UErrorCode tmpStatus = U_ZERO_ERROR; + int32_t len; + int32_t reslen = 0; + + if (U_FAILURE(*status)) { + return 0; + } + + len = uloc_getCountry(localeID, buf, sizeof(buf), &tmpStatus); + if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + return 0; + } + + if (len > 0) { + if (!_isRegionSubtag(buf, len)) { + /* invalid region code */ + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + return 0; + } else { + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, buf, uprv_min(len, capacity - reslen)); + } + reslen += len; + } + } + u_terminateChars(appendAt, capacity, reslen, status); + return reslen; +} + +static int32_t +_appendVariantsToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UBool *hadPosix, UErrorCode* status) { + char buf[ULOC_FULLNAME_CAPACITY]; + UErrorCode tmpStatus = U_ZERO_ERROR; + int32_t len, i; + int32_t reslen = 0; + + if (U_FAILURE(*status)) { + return 0; + } + + len = uloc_getVariant(localeID, buf, sizeof(buf), &tmpStatus); + if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + return 0; + } + + if (len > 0) { + char *p, *pVar; + UBool bNext = TRUE; + VariantListEntry *var; + VariantListEntry *varFirst = NULL; + + pVar = NULL; + p = buf; + while (bNext) { + if (*p == SEP || *p == LOCALE_SEP || *p == 0) { + if (*p == 0) { + bNext = FALSE; + } else { + *p = 0; /* terminate */ + } + if (pVar == NULL) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + /* ignore empty variant */ + } else { + /* ICU uses upper case letters for variants, but + the canonical format is lowercase in BCP47 */ + for (i = 0; *(pVar + i) != 0; i++) { + *(pVar + i) = uprv_tolower(*(pVar + i)); + } + + /* validate */ + if (_isVariantSubtag(pVar, -1)) { + if (uprv_strcmp(pVar,POSIX_VALUE) || len != uprv_strlen(POSIX_VALUE)) { + /* emit the variant to the list */ + var = (VariantListEntry*)uprv_malloc(sizeof(VariantListEntry)); + if (var == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + break; + } + var->variant = pVar; + if (!_addVariantToList(&varFirst, var)) { + /* duplicated variant */ + uprv_free(var); + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + } + } else { + /* Special handling for POSIX variant, need to remember that we had it and then */ + /* treat it like an extension later. */ + *hadPosix = TRUE; + } + } else if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } else if (_isPrivateuseValueSubtag(pVar, -1)) { + /* Handle private use subtags separately */ + break; + } + } + /* reset variant starting position */ + pVar = NULL; + } else if (pVar == NULL) { + pVar = p; + } + p++; + } + + if (U_SUCCESS(*status)) { + if (varFirst != NULL) { + int32_t varLen; + + /* write out validated/normalized variants to the target */ + var = varFirst; + while (var != NULL) { + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + varLen = (int32_t)uprv_strlen(var->variant); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, var->variant, uprv_min(varLen, capacity - reslen)); + } + reslen += varLen; + var = var->next; + } + } + } + + /* clean up */ + var = varFirst; + while (var != NULL) { + VariantListEntry *tmpVar = var->next; + uprv_free(var); + var = tmpVar; + } + + if (U_FAILURE(*status)) { + return 0; + } + } + + u_terminateChars(appendAt, capacity, reslen, status); + return reslen; +} + +static int32_t +_appendKeywordsToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UBool hadPosix, UErrorCode* status) { + char buf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; + char attrBuf[ULOC_KEYWORD_AND_VALUES_CAPACITY] = { 0 }; + int32_t attrBufLength = 0; + UBool isAttribute = FALSE; + UEnumeration *keywordEnum = NULL; + int32_t reslen = 0; + + keywordEnum = uloc_openKeywords(localeID, status); + if (U_FAILURE(*status) && !hadPosix) { + uenum_close(keywordEnum); + return 0; + } + if (keywordEnum != NULL || hadPosix) { + /* reorder extensions */ + int32_t len; + const char *key; + ExtensionListEntry *firstExt = NULL; + ExtensionListEntry *ext; + AttributeListEntry *firstAttr = NULL; + AttributeListEntry *attr; + char *attrValue; + char extBuf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; + char *pExtBuf = extBuf; + int32_t extBufCapacity = sizeof(extBuf); + const char *bcpKey, *bcpValue; + UErrorCode tmpStatus = U_ZERO_ERROR; + int32_t keylen; + UBool isBcpUExt; + + while (TRUE) { + isAttribute = FALSE; + key = uenum_next(keywordEnum, NULL, status); + if (key == NULL) { + break; + } + len = uloc_getKeywordValue(localeID, key, buf, sizeof(buf), &tmpStatus); + /* buf must be null-terminated */ + if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + /* ignore this keyword */ + tmpStatus = U_ZERO_ERROR; + continue; + } + + keylen = (int32_t)uprv_strlen(key); + isBcpUExt = (keylen > 1); + + /* special keyword used for representing Unicode locale attributes */ + if (uprv_strcmp(key, LOCALE_ATTRIBUTE_KEY) == 0) { + isAttribute = TRUE; + if (len > 0) { + int32_t i = 0; + while (TRUE) { + attrBufLength = 0; + for (; i < len; i++) { + if (buf[i] != '-') { + attrBuf[attrBufLength++] = buf[i]; + } else { + i++; + break; + } + } + if (attrBufLength > 0) { + attrBuf[attrBufLength] = 0; + + } else if (i >= len){ + break; + } + + /* create AttributeListEntry */ + attr = (AttributeListEntry*)uprv_malloc(sizeof(AttributeListEntry)); + if (attr == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + break; + } + attrValue = (char*)uprv_malloc(attrBufLength + 1); + if (attrValue == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + break; + } + uprv_strcpy(attrValue, attrBuf); + attr->attribute = attrValue; + + if (!_addAttributeToList(&firstAttr, attr)) { + uprv_free(attr); + uprv_free(attrValue); + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + } + } + } + } else if (isBcpUExt) { + bcpKey = uloc_toUnicodeLocaleKey(key); + if (bcpKey == NULL) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + continue; + } + + /* we've checked buf is null-terminated above */ + bcpValue = uloc_toUnicodeLocaleType(key, buf); + if (bcpValue == NULL) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + continue; + } + if (bcpValue == buf) { + /* + When uloc_toUnicodeLocaleType(key, buf) returns the + input value as is, the value is well-formed, but has + no known mapping. This implementation normalizes the + the value to lower case + */ + int32_t bcpValueLen = uprv_strlen(bcpValue); + if (bcpValueLen < extBufCapacity) { + uprv_strcpy(pExtBuf, bcpValue); + T_CString_toLowerCase(pExtBuf); + + bcpValue = pExtBuf; + + pExtBuf += (bcpValueLen + 1); + extBufCapacity -= (bcpValueLen + 1); + } else { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + continue; + } + } + } else { + if (*key == PRIVATEUSE) { + if (!_isPrivateuseValueSubtags(buf, len)) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + continue; + } + } else { + if (!_isExtensionSingleton(key, keylen) || !_isExtensionSubtags(buf, len)) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + continue; + } + } + bcpKey = key; + if ((len + 1) < extBufCapacity) { + uprv_memcpy(pExtBuf, buf, len); + bcpValue = pExtBuf; + + pExtBuf += len; + + *pExtBuf = 0; + pExtBuf++; + + extBufCapacity -= (len + 1); + } else { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + } + + if (!isAttribute) { + /* create ExtensionListEntry */ + ext = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (ext == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + break; + } + ext->key = bcpKey; + ext->value = bcpValue; + + if (!_addExtensionToList(&firstExt, ext, TRUE)) { + uprv_free(ext); + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + } + } + } + + /* Special handling for POSIX variant - add the keywords for POSIX */ + if (hadPosix) { + /* create ExtensionListEntry for POSIX */ + ext = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (ext == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + goto cleanup; + } + ext->key = POSIX_KEY; + ext->value = POSIX_VALUE; + + if (!_addExtensionToList(&firstExt, ext, TRUE)) { + uprv_free(ext); + } + } + + if (U_SUCCESS(*status) && (firstExt != NULL || firstAttr != NULL)) { + UBool startLDMLExtension = FALSE; + + attr = firstAttr; + ext = firstExt; + do { + if (!startLDMLExtension && (ext && uprv_strlen(ext->key) > 1)) { + /* write LDML singleton extension */ + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + if (reslen < capacity) { + *(appendAt + reslen) = LDMLEXT; + } + reslen++; + + startLDMLExtension = TRUE; + } + + /* write out the sorted BCP47 attributes, extensions and private use */ + if (ext && (uprv_strlen(ext->key) == 1 || attr == NULL)) { + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + len = (int32_t)uprv_strlen(ext->key); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, ext->key, uprv_min(len, capacity - reslen)); + } + reslen += len; + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + len = (int32_t)uprv_strlen(ext->value); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, ext->value, uprv_min(len, capacity - reslen)); + } + reslen += len; + + ext = ext->next; + } else if (attr) { + /* write the value for the attributes */ + if (reslen < capacity) { + *(appendAt + reslen) = SEP; + } + reslen++; + len = (int32_t)uprv_strlen(attr->attribute); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, attr->attribute, uprv_min(len, capacity - reslen)); + } + reslen += len; + + attr = attr->next; + } + } while (attr != NULL || ext != NULL); + } +cleanup: + /* clean up */ + ext = firstExt; + while (ext != NULL) { + ExtensionListEntry *tmpExt = ext->next; + uprv_free(ext); + ext = tmpExt; + } + + attr = firstAttr; + while (attr != NULL) { + AttributeListEntry *tmpAttr = attr->next; + char *pValue = (char *)attr->attribute; + uprv_free(pValue); + uprv_free(attr); + attr = tmpAttr; + } + + uenum_close(keywordEnum); + + if (U_FAILURE(*status)) { + return 0; + } + } + + return u_terminateChars(appendAt, capacity, reslen, status); +} + +/** + * Append keywords parsed from LDML extension value + * e.g. "u-ca-gregory-co-trad" -> {calendar = gregorian} {collation = traditional} + * Note: char* buf is used for storing keywords + */ +static void +_appendLDMLExtensionAsKeywords(const char* ldmlext, ExtensionListEntry** appendTo, char* buf, int32_t bufSize, UBool *posixVariant, UErrorCode *status) { + const char *pTag; /* beginning of current subtag */ + const char *pKwds; /* beginning of key-type pairs */ + UBool variantExists = *posixVariant; + + ExtensionListEntry *kwdFirst = NULL; /* first LDML keyword */ + ExtensionListEntry *kwd, *nextKwd; + + AttributeListEntry *attrFirst = NULL; /* first attribute */ + AttributeListEntry *attr, *nextAttr; + + int32_t len; + int32_t bufIdx = 0; + + char attrBuf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; + int32_t attrBufIdx = 0; + + /* Reset the posixVariant value */ + *posixVariant = FALSE; + + pTag = ldmlext; + pKwds = NULL; + + /* Iterate through u extension attributes */ + while (*pTag) { + /* locate next separator char */ + for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); + + if (ultag_isUnicodeLocaleKey(pTag, len)) { + pKwds = pTag; + break; + } + + /* add this attribute to the list */ + attr = (AttributeListEntry*)uprv_malloc(sizeof(AttributeListEntry)); + if (attr == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + goto cleanup; + } + + if (len < (int32_t)sizeof(attrBuf) - attrBufIdx) { + uprv_memcpy(&attrBuf[attrBufIdx], pTag, len); + attrBuf[attrBufIdx + len] = 0; + attr->attribute = &attrBuf[attrBufIdx]; + attrBufIdx += (len + 1); + } else { + *status = U_ILLEGAL_ARGUMENT_ERROR; + goto cleanup; + } + + if (!_addAttributeToList(&attrFirst, attr)) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + uprv_free(attr); + goto cleanup; + } + + /* next tag */ + pTag += len; + if (*pTag) { + /* next to the separator */ + pTag++; + } + } + + if (attrFirst) { + /* emit attributes as an LDML keyword, e.g. attribute=attr1-attr2 */ + + if (attrBufIdx > bufSize) { + /* attrBufIdx == <total length of attribute subtag> + 1 */ + *status = U_ILLEGAL_ARGUMENT_ERROR; + goto cleanup; + } + + kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (kwd == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + goto cleanup; + } + + kwd->key = LOCALE_ATTRIBUTE_KEY; + kwd->value = buf; + + /* attribute subtags sorted in alphabetical order as type */ + attr = attrFirst; + while (attr != NULL) { + nextAttr = attr->next; + + /* buffer size check is done above */ + if (attr != attrFirst) { + *(buf + bufIdx) = SEP; + bufIdx++; + } + + len = uprv_strlen(attr->attribute); + uprv_memcpy(buf + bufIdx, attr->attribute, len); + bufIdx += len; + + attr = nextAttr; + } + *(buf + bufIdx) = 0; + bufIdx++; + + if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + uprv_free(kwd); + goto cleanup; + } + + /* once keyword entry is created, delete the attribute list */ + attr = attrFirst; + while (attr != NULL) { + nextAttr = attr->next; + uprv_free(attr); + attr = nextAttr; + } + attrFirst = NULL; + } + + if (pKwds) { + const char *pBcpKey = NULL; /* u extenstion key subtag */ + const char *pBcpType = NULL; /* beginning of u extension type subtag(s) */ + int32_t bcpKeyLen = 0; + int32_t bcpTypeLen = 0; + UBool isDone = FALSE; + + pTag = pKwds; + /* BCP47 representation of LDML key/type pairs */ + while (!isDone) { + const char *pNextBcpKey = NULL; + int32_t nextBcpKeyLen = 0; + UBool emitKeyword = FALSE; + + if (*pTag) { + /* locate next separator char */ + for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); + + if (ultag_isUnicodeLocaleKey(pTag, len)) { + if (pBcpKey) { + emitKeyword = TRUE; + pNextBcpKey = pTag; + nextBcpKeyLen = len; + } else { + pBcpKey = pTag; + bcpKeyLen = len; + } + } else { + U_ASSERT(pBcpKey != NULL); + /* within LDML type subtags */ + if (pBcpType) { + bcpTypeLen += (len + 1); + } else { + pBcpType = pTag; + bcpTypeLen = len; + } + } + + /* next tag */ + pTag += len; + if (*pTag) { + /* next to the separator */ + pTag++; + } + } else { + /* processing last one */ + emitKeyword = TRUE; + isDone = TRUE; + } + + if (emitKeyword) { + const char *pKey = NULL; /* LDML key */ + const char *pType = NULL; /* LDML type */ + + char bcpKeyBuf[9]; /* BCP key length is always 2 for now */ + + U_ASSERT(pBcpKey != NULL); + + if (bcpKeyLen >= sizeof(bcpKeyBuf)) { + /* the BCP key is invalid */ + *status = U_ILLEGAL_ARGUMENT_ERROR; + goto cleanup; + } + + uprv_strncpy(bcpKeyBuf, pBcpKey, bcpKeyLen); + bcpKeyBuf[bcpKeyLen] = 0; + + /* u extension key to LDML key */ + pKey = uloc_toLegacyKey(bcpKeyBuf); + if (pKey == NULL) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + goto cleanup; + } + if (pKey == bcpKeyBuf) { + /* + The key returned by toLegacyKey points to the input buffer. + We normalize the result key to lower case. + */ + T_CString_toLowerCase(bcpKeyBuf); + if (bufSize - bufIdx - 1 >= bcpKeyLen) { + uprv_memcpy(buf + bufIdx, bcpKeyBuf, bcpKeyLen); + pKey = buf + bufIdx; + bufIdx += bcpKeyLen; + *(buf + bufIdx) = 0; + bufIdx++; + } else { + *status = U_BUFFER_OVERFLOW_ERROR; + goto cleanup; + } + } + + if (pBcpType) { + char bcpTypeBuf[128]; /* practically long enough even considering multiple subtag type */ + if (bcpTypeLen >= sizeof(bcpTypeBuf)) { + /* the BCP type is too long */ + *status = U_ILLEGAL_ARGUMENT_ERROR; + goto cleanup; + } + + uprv_strncpy(bcpTypeBuf, pBcpType, bcpTypeLen); + bcpTypeBuf[bcpTypeLen] = 0; + + /* BCP type to locale type */ + pType = uloc_toLegacyType(pKey, bcpTypeBuf); + if (pType == NULL) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + goto cleanup; + } + if (pType == bcpTypeBuf) { + /* + The type returned by toLegacyType points to the input buffer. + We normalize the result type to lower case. + */ + /* normalize to lower case */ + T_CString_toLowerCase(bcpTypeBuf); + if (bufSize - bufIdx - 1 >= bcpTypeLen) { + uprv_memcpy(buf + bufIdx, bcpTypeBuf, bcpTypeLen); + pType = buf + bufIdx; + bufIdx += bcpTypeLen; + *(buf + bufIdx) = 0; + bufIdx++; + } else { + *status = U_BUFFER_OVERFLOW_ERROR; + goto cleanup; + } + } + } else { + /* typeless - default type value is "yes" */ + pType = LOCALE_TYPE_YES; + } + + /* Special handling for u-va-posix, since we want to treat this as a variant, + not as a keyword */ + if (!variantExists && !uprv_strcmp(pKey, POSIX_KEY) && !uprv_strcmp(pType, POSIX_VALUE) ) { + *posixVariant = TRUE; + } else { + /* create an ExtensionListEntry for this keyword */ + kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (kwd == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + goto cleanup; + } + + kwd->key = pKey; + kwd->value = pType; + + if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + uprv_free(kwd); + goto cleanup; + } + } + + pBcpKey = pNextBcpKey; + bcpKeyLen = pNextBcpKey != NULL ? nextBcpKeyLen : 0; + pBcpType = NULL; + bcpTypeLen = 0; + } + } + } + + kwd = kwdFirst; + while (kwd != NULL) { + nextKwd = kwd->next; + _addExtensionToList(appendTo, kwd, FALSE); + kwd = nextKwd; + } + + return; + +cleanup: + attr = attrFirst; + while (attr != NULL) { + nextAttr = attr->next; + uprv_free(attr); + attr = nextAttr; + } + + kwd = kwdFirst; + while (kwd != NULL) { + nextKwd = kwd->next; + uprv_free(kwd); + kwd = nextKwd; + } +} + + +static int32_t +_appendKeywords(ULanguageTag* langtag, char* appendAt, int32_t capacity, UErrorCode* status) { + int32_t reslen = 0; + int32_t i, n; + int32_t len; + ExtensionListEntry *kwdFirst = NULL; + ExtensionListEntry *kwd; + const char *key, *type; + char *kwdBuf = NULL; + int32_t kwdBufLength = capacity; + UBool posixVariant = FALSE; + + if (U_FAILURE(*status)) { + return 0; + } + + kwdBuf = (char*)uprv_malloc(kwdBufLength); + if (kwdBuf == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + return 0; + } + + /* Determine if variants already exists */ + if (ultag_getVariantsSize(langtag)) { + posixVariant = TRUE; + } + + n = ultag_getExtensionsSize(langtag); + + /* resolve locale keywords and reordering keys */ + for (i = 0; i < n; i++) { + key = ultag_getExtensionKey(langtag, i); + type = ultag_getExtensionValue(langtag, i); + if (*key == LDMLEXT) { + _appendLDMLExtensionAsKeywords(type, &kwdFirst, kwdBuf, kwdBufLength, &posixVariant, status); + if (U_FAILURE(*status)) { + break; + } + } else { + kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (kwd == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + break; + } + kwd->key = key; + kwd->value = type; + if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { + uprv_free(kwd); + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } + } + } + + if (U_SUCCESS(*status)) { + type = ultag_getPrivateUse(langtag); + if ((int32_t)uprv_strlen(type) > 0) { + /* add private use as a keyword */ + kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (kwd == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + } else { + kwd->key = PRIVATEUSE_KEY; + kwd->value = type; + if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { + uprv_free(kwd); + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + } + } + } + + /* If a POSIX variant was in the extensions, write it out before writing the keywords. */ + + if (U_SUCCESS(*status) && posixVariant) { + len = (int32_t) uprv_strlen(_POSIX); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, _POSIX, uprv_min(len, capacity - reslen)); + } + reslen += len; + } + + if (U_SUCCESS(*status) && kwdFirst != NULL) { + /* write out the sorted keywords */ + UBool firstValue = TRUE; + kwd = kwdFirst; + do { + if (reslen < capacity) { + if (firstValue) { + /* '@' */ + *(appendAt + reslen) = LOCALE_EXT_SEP; + firstValue = FALSE; + } else { + /* ';' */ + *(appendAt + reslen) = LOCALE_KEYWORD_SEP; + } + } + reslen++; + + /* key */ + len = (int32_t)uprv_strlen(kwd->key); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, kwd->key, uprv_min(len, capacity - reslen)); + } + reslen += len; + + /* '=' */ + if (reslen < capacity) { + *(appendAt + reslen) = LOCALE_KEY_TYPE_SEP; + } + reslen++; + + /* type */ + len = (int32_t)uprv_strlen(kwd->value); + if (reslen < capacity) { + uprv_memcpy(appendAt + reslen, kwd->value, uprv_min(len, capacity - reslen)); + } + reslen += len; + + kwd = kwd->next; + } while (kwd); + } + + /* clean up */ + kwd = kwdFirst; + while (kwd != NULL) { + ExtensionListEntry *tmpKwd = kwd->next; + uprv_free(kwd); + kwd = tmpKwd; + } + + uprv_free(kwdBuf); + + if (U_FAILURE(*status)) { + return 0; + } + + return u_terminateChars(appendAt, capacity, reslen, status); +} + +static int32_t +_appendPrivateuseToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UBool hadPosix, UErrorCode* status) { + char buf[ULOC_FULLNAME_CAPACITY]; + char tmpAppend[ULOC_FULLNAME_CAPACITY]; + UErrorCode tmpStatus = U_ZERO_ERROR; + int32_t len, i; + int32_t reslen = 0; + + if (U_FAILURE(*status)) { + return 0; + } + + len = uloc_getVariant(localeID, buf, sizeof(buf), &tmpStatus); + if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { + if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + } + return 0; + } + + if (len > 0) { + char *p, *pPriv; + UBool bNext = TRUE; + UBool firstValue = TRUE; + UBool writeValue; + + pPriv = NULL; + p = buf; + while (bNext) { + writeValue = FALSE; + if (*p == SEP || *p == LOCALE_SEP || *p == 0) { + if (*p == 0) { + bNext = FALSE; + } else { + *p = 0; /* terminate */ + } + if (pPriv != NULL) { + /* Private use in the canonical format is lowercase in BCP47 */ + for (i = 0; *(pPriv + i) != 0; i++) { + *(pPriv + i) = uprv_tolower(*(pPriv + i)); + } + + /* validate */ + if (_isPrivateuseValueSubtag(pPriv, -1)) { + if (firstValue) { + if (!_isVariantSubtag(pPriv, -1)) { + writeValue = TRUE; + } + } else { + writeValue = TRUE; + } + } else if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + break; + } else { + break; + } + + if (writeValue) { + if (reslen < capacity) { + tmpAppend[reslen++] = SEP; + } + + if (firstValue) { + if (reslen < capacity) { + tmpAppend[reslen++] = *PRIVATEUSE_KEY; + } + + if (reslen < capacity) { + tmpAppend[reslen++] = SEP; + } + + len = (int32_t)uprv_strlen(PRIVUSE_VARIANT_PREFIX); + if (reslen < capacity) { + uprv_memcpy(tmpAppend + reslen, PRIVUSE_VARIANT_PREFIX, uprv_min(len, capacity - reslen)); + } + reslen += len; + + if (reslen < capacity) { + tmpAppend[reslen++] = SEP; + } + + firstValue = FALSE; + } + + len = (int32_t)uprv_strlen(pPriv); + if (reslen < capacity) { + uprv_memcpy(tmpAppend + reslen, pPriv, uprv_min(len, capacity - reslen)); + } + reslen += len; + } + } + /* reset private use starting position */ + pPriv = NULL; + } else if (pPriv == NULL) { + pPriv = p; + } + p++; + } + + if (U_FAILURE(*status)) { + return 0; + } + } + + if (U_SUCCESS(*status)) { + len = reslen; + if (reslen < capacity) { + uprv_memcpy(appendAt, tmpAppend, uprv_min(len, capacity - reslen)); + } + } + + u_terminateChars(appendAt, capacity, reslen, status); + + return reslen; +} + +/* +* ------------------------------------------------- +* +* ultag_ functions +* +* ------------------------------------------------- +*/ + +/* Bit flags used by the parser */ +#define LANG 0x0001 +#define EXTL 0x0002 +#define SCRT 0x0004 +#define REGN 0x0008 +#define VART 0x0010 +#define EXTS 0x0020 +#define EXTV 0x0040 +#define PRIV 0x0080 + +static ULanguageTag* +ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* status) { + ULanguageTag *t; + char *tagBuf; + int16_t next; + char *pSubtag, *pNext, *pLastGoodPosition; + int32_t subtagLen; + int32_t extlangIdx; + ExtensionListEntry *pExtension; + char *pExtValueSubtag, *pExtValueSubtagEnd; + int32_t i; + UBool privateuseVar = FALSE; + int32_t grandfatheredLen = 0; + + if (parsedLen != NULL) { + *parsedLen = 0; + } + + if (U_FAILURE(*status)) { + return NULL; + } + + if (tagLen < 0) { + tagLen = (int32_t)uprv_strlen(tag); + } + + /* copy the entire string */ + tagBuf = (char*)uprv_malloc(tagLen + 1); + if (tagBuf == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + return NULL; + } + uprv_memcpy(tagBuf, tag, tagLen); + *(tagBuf + tagLen) = 0; + + /* create a ULanguageTag */ + t = (ULanguageTag*)uprv_malloc(sizeof(ULanguageTag)); + if (t == NULL) { + uprv_free(tagBuf); + *status = U_MEMORY_ALLOCATION_ERROR; + return NULL; + } + _initializeULanguageTag(t); + t->buf = tagBuf; + + if (tagLen < MINLEN) { + /* the input tag is too short - return empty ULanguageTag */ + return t; + } + + /* check if the tag is grandfathered */ + for (i = 0; GRANDFATHERED[i] != NULL; i += 2) { + if (uprv_stricmp(GRANDFATHERED[i], tagBuf) == 0) { + int32_t newTagLength; + + grandfatheredLen = tagLen; /* back up for output parsedLen */ + newTagLength = uprv_strlen(GRANDFATHERED[i+1]); + if (tagLen < newTagLength) { + uprv_free(tagBuf); + tagBuf = (char*)uprv_malloc(newTagLength + 1); + if (tagBuf == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + ultag_close(t); + return NULL; + } + t->buf = tagBuf; + tagLen = newTagLength; + } + uprv_strcpy(t->buf, GRANDFATHERED[i + 1]); + break; + } + } + + /* + * langtag = language + * ["-" script] + * ["-" region] + * *("-" variant) + * *("-" extension) + * ["-" privateuse] + */ + + next = LANG | PRIV; + pNext = pLastGoodPosition = tagBuf; + extlangIdx = 0; + pExtension = NULL; + pExtValueSubtag = NULL; + pExtValueSubtagEnd = NULL; + + while (pNext) { + char *pSep; + + pSubtag = pNext; + + /* locate next separator char */ + pSep = pSubtag; + while (*pSep) { + if (*pSep == SEP) { + break; + } + pSep++; + } + if (*pSep == 0) { + /* last subtag */ + pNext = NULL; + } else { + pNext = pSep + 1; + } + subtagLen = (int32_t)(pSep - pSubtag); + + if (next & LANG) { + if (_isLanguageSubtag(pSubtag, subtagLen)) { + *pSep = 0; /* terminate */ + t->language = T_CString_toLowerCase(pSubtag); + + pLastGoodPosition = pSep; + next = EXTL | SCRT | REGN | VART | EXTS | PRIV; + continue; + } + } + if (next & EXTL) { + if (_isExtlangSubtag(pSubtag, subtagLen)) { + *pSep = 0; + t->extlang[extlangIdx++] = T_CString_toLowerCase(pSubtag); + + pLastGoodPosition = pSep; + if (extlangIdx < 3) { + next = EXTL | SCRT | REGN | VART | EXTS | PRIV; + } else { + next = SCRT | REGN | VART | EXTS | PRIV; + } + continue; + } + } + if (next & SCRT) { + if (_isScriptSubtag(pSubtag, subtagLen)) { + char *p = pSubtag; + + *pSep = 0; + + /* to title case */ + *p = uprv_toupper(*p); + p++; + for (; *p; p++) { + *p = uprv_tolower(*p); + } + + t->script = pSubtag; + + pLastGoodPosition = pSep; + next = REGN | VART | EXTS | PRIV; + continue; + } + } + if (next & REGN) { + if (_isRegionSubtag(pSubtag, subtagLen)) { + *pSep = 0; + t->region = T_CString_toUpperCase(pSubtag); + + pLastGoodPosition = pSep; + next = VART | EXTS | PRIV; + continue; + } + } + if (next & VART) { + if (_isVariantSubtag(pSubtag, subtagLen) || + (privateuseVar && _isPrivateuseVariantSubtag(pSubtag, subtagLen))) { + VariantListEntry *var; + UBool isAdded; + + var = (VariantListEntry*)uprv_malloc(sizeof(VariantListEntry)); + if (var == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + goto error; + } + *pSep = 0; + var->variant = T_CString_toUpperCase(pSubtag); + isAdded = _addVariantToList(&(t->variants), var); + if (!isAdded) { + /* duplicated variant entry */ + uprv_free(var); + break; + } + pLastGoodPosition = pSep; + next = VART | EXTS | PRIV; + continue; + } + } + if (next & EXTS) { + if (_isExtensionSingleton(pSubtag, subtagLen)) { + if (pExtension != NULL) { + if (pExtValueSubtag == NULL || pExtValueSubtagEnd == NULL) { + /* the previous extension is incomplete */ + uprv_free(pExtension); + pExtension = NULL; + break; + } + + /* terminate the previous extension value */ + *pExtValueSubtagEnd = 0; + pExtension->value = T_CString_toLowerCase(pExtValueSubtag); + + /* insert the extension to the list */ + if (_addExtensionToList(&(t->extensions), pExtension, FALSE)) { + pLastGoodPosition = pExtValueSubtagEnd; + } else { + /* stop parsing here */ + uprv_free(pExtension); + pExtension = NULL; + break; + } + } + + /* create a new extension */ + pExtension = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); + if (pExtension == NULL) { + *status = U_MEMORY_ALLOCATION_ERROR; + goto error; + } + *pSep = 0; + pExtension->key = T_CString_toLowerCase(pSubtag); + pExtension->value = NULL; /* will be set later */ + + /* + * reset the start and the end location of extension value + * subtags for this extension + */ + pExtValueSubtag = NULL; + pExtValueSubtagEnd = NULL; + + next = EXTV; + continue; + } + } + if (next & EXTV) { + if (_isExtensionSubtag(pSubtag, subtagLen)) { + if (pExtValueSubtag == NULL) { + /* if the start postion of this extension's value is not yet, + this one is the first value subtag */ + pExtValueSubtag = pSubtag; + } + + /* Mark the end of this subtag */ + pExtValueSubtagEnd = pSep; + next = EXTS | EXTV | PRIV; + + continue; + } + } + if (next & PRIV) { + if (uprv_tolower(*pSubtag) == PRIVATEUSE) { + char *pPrivuseVal; + + if (pExtension != NULL) { + /* Process the last extension */ + if (pExtValueSubtag == NULL || pExtValueSubtagEnd == NULL) { + /* the previous extension is incomplete */ + uprv_free(pExtension); + pExtension = NULL; + break; + } else { + /* terminate the previous extension value */ + *pExtValueSubtagEnd = 0; + pExtension->value = T_CString_toLowerCase(pExtValueSubtag); + + /* insert the extension to the list */ + if (_addExtensionToList(&(t->extensions), pExtension, FALSE)) { + pLastGoodPosition = pExtValueSubtagEnd; + pExtension = NULL; + } else { + /* stop parsing here */ + uprv_free(pExtension); + pExtension = NULL; + break; + } + } + } + + /* The rest of part will be private use value subtags */ + if (pNext == NULL) { + /* empty private use subtag */ + break; + } + /* back up the private use value start position */ + pPrivuseVal = pNext; + + /* validate private use value subtags */ + while (pNext) { + pSubtag = pNext; + pSep = pSubtag; + while (*pSep) { + if (*pSep == SEP) { + break; + } + pSep++; + } + if (*pSep == 0) { + /* last subtag */ + pNext = NULL; + } else { + pNext = pSep + 1; + } + subtagLen = (int32_t)(pSep - pSubtag); + + if (uprv_strncmp(pSubtag, PRIVUSE_VARIANT_PREFIX, uprv_strlen(PRIVUSE_VARIANT_PREFIX)) == 0) { + *pSep = 0; + next = VART; + privateuseVar = TRUE; + break; + } else if (_isPrivateuseValueSubtag(pSubtag, subtagLen)) { + pLastGoodPosition = pSep; + } else { + break; + } + } + + if (next == VART) { + continue; + } + + if (pLastGoodPosition - pPrivuseVal > 0) { + *pLastGoodPosition = 0; + t->privateuse = T_CString_toLowerCase(pPrivuseVal); + } + /* No more subtags, exiting the parse loop */ + break; + } + break; + } + + /* If we fell through here, it means this subtag is illegal - quit parsing */ + break; + } + + if (pExtension != NULL) { + /* Process the last extension */ + if (pExtValueSubtag == NULL || pExtValueSubtagEnd == NULL) { + /* the previous extension is incomplete */ + uprv_free(pExtension); + } else { + /* terminate the previous extension value */ + *pExtValueSubtagEnd = 0; + pExtension->value = T_CString_toLowerCase(pExtValueSubtag); + /* insert the extension to the list */ + if (_addExtensionToList(&(t->extensions), pExtension, FALSE)) { + pLastGoodPosition = pExtValueSubtagEnd; + } else { + uprv_free(pExtension); + } + } + } + + if (parsedLen != NULL) { + *parsedLen = (grandfatheredLen > 0) ? grandfatheredLen : (int32_t)(pLastGoodPosition - t->buf); + } + + return t; + +error: + ultag_close(t); + return NULL; +} + +static void +ultag_close(ULanguageTag* langtag) { + + if (langtag == NULL) { + return; + } + + uprv_free(langtag->buf); + + if (langtag->variants) { + VariantListEntry *curVar = langtag->variants; + while (curVar) { + VariantListEntry *nextVar = curVar->next; + uprv_free(curVar); + curVar = nextVar; + } + } + + if (langtag->extensions) { + ExtensionListEntry *curExt = langtag->extensions; + while (curExt) { + ExtensionListEntry *nextExt = curExt->next; + uprv_free(curExt); + curExt = nextExt; + } + } + + uprv_free(langtag); +} + +static const char* +ultag_getLanguage(const ULanguageTag* langtag) { + return langtag->language; +} + +#if 0 +static const char* +ultag_getJDKLanguage(const ULanguageTag* langtag) { + int32_t i; + for (i = 0; DEPRECATEDLANGS[i] != NULL; i += 2) { + if (uprv_compareInvCharsAsAscii(DEPRECATEDLANGS[i], langtag->language) == 0) { + return DEPRECATEDLANGS[i + 1]; + } + } + return langtag->language; +} +#endif + +static const char* +ultag_getExtlang(const ULanguageTag* langtag, int32_t idx) { + if (idx >= 0 && idx < MAXEXTLANG) { + return langtag->extlang[idx]; + } + return NULL; +} + +static int32_t +ultag_getExtlangSize(const ULanguageTag* langtag) { + int32_t size = 0; + int32_t i; + for (i = 0; i < MAXEXTLANG; i++) { + if (langtag->extlang[i]) { + size++; + } + } + return size; +} + +static const char* +ultag_getScript(const ULanguageTag* langtag) { + return langtag->script; +} + +static const char* +ultag_getRegion(const ULanguageTag* langtag) { + return langtag->region; +} + +static const char* +ultag_getVariant(const ULanguageTag* langtag, int32_t idx) { + const char *var = NULL; + VariantListEntry *cur = langtag->variants; + int32_t i = 0; + while (cur) { + if (i == idx) { + var = cur->variant; + break; + } + cur = cur->next; + i++; + } + return var; +} + +static int32_t +ultag_getVariantsSize(const ULanguageTag* langtag) { + int32_t size = 0; + VariantListEntry *cur = langtag->variants; + while (TRUE) { + if (cur == NULL) { + break; + } + size++; + cur = cur->next; + } + return size; +} + +static const char* +ultag_getExtensionKey(const ULanguageTag* langtag, int32_t idx) { + const char *key = NULL; + ExtensionListEntry *cur = langtag->extensions; + int32_t i = 0; + while (cur) { + if (i == idx) { + key = cur->key; + break; + } + cur = cur->next; + i++; + } + return key; +} + +static const char* +ultag_getExtensionValue(const ULanguageTag* langtag, int32_t idx) { + const char *val = NULL; + ExtensionListEntry *cur = langtag->extensions; + int32_t i = 0; + while (cur) { + if (i == idx) { + val = cur->value; + break; + } + cur = cur->next; + i++; + } + return val; +} + +static int32_t +ultag_getExtensionsSize(const ULanguageTag* langtag) { + int32_t size = 0; + ExtensionListEntry *cur = langtag->extensions; + while (TRUE) { + if (cur == NULL) { + break; + } + size++; + cur = cur->next; + } + return size; +} + +static const char* +ultag_getPrivateUse(const ULanguageTag* langtag) { + return langtag->privateuse; +} + +#if 0 +static const char* +ultag_getGrandfathered(const ULanguageTag* langtag) { + return langtag->grandfathered; +} +#endif + + +/* +* ------------------------------------------------- +* +* Locale/BCP47 conversion APIs, exposed as uloc_* +* +* ------------------------------------------------- +*/ +U_CAPI int32_t U_EXPORT2 +uloc_toLanguageTag(const char* localeID, + char* langtag, + int32_t langtagCapacity, + UBool strict, + UErrorCode* status) { + /* char canonical[ULOC_FULLNAME_CAPACITY]; */ /* See #6822 */ + char canonical[256]; + int32_t reslen = 0; + UErrorCode tmpStatus = U_ZERO_ERROR; + UBool hadPosix = FALSE; + const char* pKeywordStart; + + /* Note: uloc_canonicalize returns "en_US_POSIX" for input locale ID "". See #6835 */ + canonical[0] = 0; + if (uprv_strlen(localeID) > 0) { + uloc_canonicalize(localeID, canonical, sizeof(canonical), &tmpStatus); + if (tmpStatus != U_ZERO_ERROR) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + } + + /* For handling special case - private use only tag */ + pKeywordStart = locale_getKeywordsStart(canonical); + if (pKeywordStart == canonical) { + UEnumeration *kwdEnum; + int kwdCnt = 0; + UBool done = FALSE; + + kwdEnum = uloc_openKeywords((const char*)canonical, &tmpStatus); + if (kwdEnum != NULL) { + kwdCnt = uenum_count(kwdEnum, &tmpStatus); + if (kwdCnt == 1) { + const char *key; + int32_t len = 0; + + key = uenum_next(kwdEnum, &len, &tmpStatus); + if (len == 1 && *key == PRIVATEUSE) { + char buf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; + buf[0] = PRIVATEUSE; + buf[1] = SEP; + len = uloc_getKeywordValue(localeID, key, &buf[2], sizeof(buf) - 2, &tmpStatus); + if (U_SUCCESS(tmpStatus)) { + if (_isPrivateuseValueSubtags(&buf[2], len)) { + /* return private use only tag */ + reslen = len + 2; + uprv_memcpy(langtag, buf, uprv_min(reslen, langtagCapacity)); + u_terminateChars(langtag, langtagCapacity, reslen, status); + done = TRUE; + } else if (strict) { + *status = U_ILLEGAL_ARGUMENT_ERROR; + done = TRUE; + } + /* if not strict mode, then "und" will be returned */ + } else { + *status = U_ILLEGAL_ARGUMENT_ERROR; + done = TRUE; + } + } + } + uenum_close(kwdEnum); + if (done) { + return reslen; + } + } + } + + reslen += _appendLanguageToLanguageTag(canonical, langtag, langtagCapacity, strict, status); + reslen += _appendScriptToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, status); + reslen += _appendRegionToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, status); + reslen += _appendVariantsToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, &hadPosix, status); + reslen += _appendKeywordsToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, hadPosix, status); + reslen += _appendPrivateuseToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, hadPosix, status); + + return reslen; +} + + +U_CAPI int32_t U_EXPORT2 +uloc_forLanguageTag(const char* langtag, + char* localeID, + int32_t localeIDCapacity, + int32_t* parsedLength, + UErrorCode* status) { + ULanguageTag *lt; + int32_t reslen = 0; + const char *subtag, *p; + int32_t len; + int32_t i, n; + UBool noRegion = TRUE; + + lt = ultag_parse(langtag, -1, parsedLength, status); + if (U_FAILURE(*status)) { + return 0; + } + + /* language */ + subtag = ultag_getExtlangSize(lt) > 0 ? ultag_getExtlang(lt, 0) : ultag_getLanguage(lt); + if (uprv_compareInvCharsAsAscii(subtag, LANG_UND) != 0) { + len = (int32_t)uprv_strlen(subtag); + if (len > 0) { + if (reslen < localeIDCapacity) { + uprv_memcpy(localeID, subtag, uprv_min(len, localeIDCapacity - reslen)); + } + reslen += len; + } + } + + /* script */ + subtag = ultag_getScript(lt); + len = (int32_t)uprv_strlen(subtag); + if (len > 0) { + if (reslen < localeIDCapacity) { + *(localeID + reslen) = LOCALE_SEP; + } + reslen++; + + /* write out the script in title case */ + p = subtag; + while (*p) { + if (reslen < localeIDCapacity) { + if (p == subtag) { + *(localeID + reslen) = uprv_toupper(*p); + } else { + *(localeID + reslen) = *p; + } + } + reslen++; + p++; + } + } + + /* region */ + subtag = ultag_getRegion(lt); + len = (int32_t)uprv_strlen(subtag); + if (len > 0) { + if (reslen < localeIDCapacity) { + *(localeID + reslen) = LOCALE_SEP; + } + reslen++; + /* write out the retion in upper case */ + p = subtag; + while (*p) { + if (reslen < localeIDCapacity) { + *(localeID + reslen) = uprv_toupper(*p); + } + reslen++; + p++; + } + noRegion = FALSE; + } + + /* variants */ + n = ultag_getVariantsSize(lt); + if (n > 0) { + if (noRegion) { + if (reslen < localeIDCapacity) { + *(localeID + reslen) = LOCALE_SEP; + } + reslen++; + } + + for (i = 0; i < n; i++) { + subtag = ultag_getVariant(lt, i); + if (reslen < localeIDCapacity) { + *(localeID + reslen) = LOCALE_SEP; + } + reslen++; + /* write out the variant in upper case */ + p = subtag; + while (*p) { + if (reslen < localeIDCapacity) { + *(localeID + reslen) = uprv_toupper(*p); + } + reslen++; + p++; + } + } + } + + /* keywords */ + n = ultag_getExtensionsSize(lt); + subtag = ultag_getPrivateUse(lt); + if (n > 0 || uprv_strlen(subtag) > 0) { + if (reslen == 0 && n > 0) { + /* need a language */ + if (reslen < localeIDCapacity) { + uprv_memcpy(localeID + reslen, LANG_UND, uprv_min(LANG_UND_LEN, localeIDCapacity - reslen)); + } + reslen += LANG_UND_LEN; + } + len = _appendKeywords(lt, localeID + reslen, localeIDCapacity - reslen, status); + reslen += len; + } + + ultag_close(lt); + return u_terminateChars(localeID, localeIDCapacity, reslen, status); +} |