typedefstruct CanonicalizationMap { constchar *id; /* input ID */ constchar *canonicalID; /* canonicalized output ID */
} CanonicalizationMap;
/** * A map to canonicalize locale IDs. This handles a variety of * different semantic kinds of transformations.
*/
constexpr CanonicalizationMap CANONICALIZE_MAP[] = {
{ "art__LOJBAN", "jbo" }, /* registered name */
{ "hy__AREVELA", "hy" }, /* Registered IANA variant */
{ "hy__AREVMDA", "hyw" }, /* Registered IANA variant */
{ "zh__GUOYU", "zh" }, /* registered name */
{ "zh__HAKKA", "hak" }, /* registered name */
{ "zh__XIANG", "hsn" }, /* registered name */ // subtags with 3 chars won't be treated as variants.
{ "zh_GAN", "gan" }, /* registered name */
{ "zh_MIN_NAN", "nan" }, /* registered name */
{ "zh_WUU", "wuu" }, /* registered name */
{ "zh_YUE", "yue" }, /* registered name */
};
/* ### BCP47 Conversion *******************************************/ /* Gets the size of the shortest subtag in the given localeID. */
int32_t getShortestSubtagLength(constchar *localeID) {
int32_t localeIDLength = static_cast<int32_t>(uprv_strlen(localeID));
int32_t length = localeIDLength;
int32_t tmpLength = 0;
int32_t i; bool reset = true;
for (i = 0; i < localeIDLength; i++) { if (localeID[i] != '_' && localeID[i] != '-') { if (reset) {
tmpLength = 0;
reset = false;
}
tmpLength++;
} else { if (tmpLength != 0 && tmpLength < length) {
length = tmpLength;
}
reset = true;
}
}
return length;
} /* Test if the locale id has BCP47 u extension and does not have '@' */ inlinebool _hasBCP47Extension(constchar *id) { return id != nullptr && uprv_strstr(id, "@") == nullptr && getShortestSubtagLength(id) == 1;
}
/* ### Keywords **************************************************/ inlinebool UPRV_ISDIGIT(char c) { return c >= '0' && c <= '9'; } inlinebool UPRV_ISALPHANUM(char c) { return uprv_isASCIILetter(c) || UPRV_ISDIGIT(c); } /* Punctuation/symbols allowed in legacy key values */ inlinebool UPRV_OK_VALUE_PUNCTUATION(char c) { return c == '_' || c == '-' || c == '+' || c == '/'; }
U_CAPI constchar * U_EXPORT2
locale_getKeywordsStart(constchar *localeID) { constchar *result = nullptr; if((result = uprv_strchr(localeID, '@')) != nullptr) { return result;
} #if (U_CHARSET_FAMILY == U_EBCDIC_FAMILY) else { /* We do this because the @ sign is variant, and the @ sign used on one EBCDIC machine won't be compiled the same way on other EBCDIC based
machines. */ staticconst uint8_t ebcdicSigns[] = { 0x7C, 0x44, 0x66, 0x80, 0xAC, 0xAE, 0xAF, 0xB5, 0xEC, 0xEF, 0x00 }; const uint8_t *charToFind = ebcdicSigns; while(*charToFind) { if((result = uprv_strchr(localeID, *charToFind)) != nullptr) { return result;
}
charToFind++;
}
} #endif return nullptr;
}
namespace {
/** * @param keywordName incoming name to be canonicalized * @param status return status (keyword too long) * @return the keyword name
*/
CharString locale_canonKeywordName(std::string_view keywordName, UErrorCode& status)
{ if (U_FAILURE(status)) { return {}; }
CharString result;
for (char c : keywordName) { if (!UPRV_ISALPHANUM(c)) {
status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed keyword name */ return {};
}
result.append(uprv_tolower(c), status);
} if (result.isEmpty()) {
status = U_ILLEGAL_ARGUMENT_ERROR; /* empty keyword name */ return {};
}
if(prev == '@') { /* start of keyword definition */ /* we will grab pairs, trim spaces, lowercase keywords, sort and return */ do { bool duplicate = false; /* skip leading spaces */ while(*pos == ' ') {
pos++;
} if (!*pos) { /* handle trailing "; " */ break;
} if(numKeywords == maxKeywords) {
status = U_INTERNAL_PROGRAM_ERROR; return;
}
equalSign = uprv_strchr(pos, '=');
semicolon = uprv_strchr(pos, ';'); /* lack of '=' [foo@currency] is illegal */ /* ';' before '=' [foo@currency;collation=pinyin] is illegal */ if(!equalSign || (semicolon && semicolon<equalSign)) {
status = U_INVALID_FORMAT_ERROR; return;
} /* need to normalize both keyword and keyword name */ if(equalSign - pos >= ULOC_KEYWORD_BUFFER_LEN) { /* keyword name too long for internal buffer */
status = U_INTERNAL_PROGRAM_ERROR; return;
} for(i = 0, n = 0; i < equalSign - pos; ++i) { if (pos[i] != ' ') {
keywordList[numKeywords].keyword[n++] = uprv_tolower(pos[i]);
}
}
/* zero-length keyword is an error. */ if (n == 0) {
status = U_INVALID_FORMAT_ERROR; return;
}
keywordList[numKeywords].keyword[n] = 0;
keywordList[numKeywords].keywordLen = n; /* now grab the value part. First we skip the '=' */
equalSign++; /* then we leading spaces */ while(*equalSign == ' ') {
equalSign++;
}
/* Premature end or zero-length value */ if (!*equalSign || equalSign == semicolon) {
status = U_INVALID_FORMAT_ERROR; return;
}
keywordList[numKeywords].valueStart = equalSign;
pos = semicolon;
i = 0; if(pos) { while(*(pos - i - 1) == ' ') {
i++;
}
keywordList[numKeywords].valueLen = static_cast<int32_t>(pos - equalSign - i);
pos++;
} else {
i = static_cast<int32_t>(uprv_strlen(equalSign)); while(i && equalSign[i-1] == ' ') {
i--;
}
keywordList[numKeywords].valueLen = i;
} /* If this is a duplicate keyword, then ignore it */ for (j=0; j<numKeywords; ++j) { if (uprv_strcmp(keywordList[j].keyword, keywordList[numKeywords].keyword) == 0) {
duplicate = true; break;
}
} if (!duplicate) {
++numKeywords;
}
} while(pos);
/* now we have a list of keywords */ /* we need to sort it */
uprv_sortArray(keywordList, numKeywords, sizeof(KeywordStruct), compareKeywordStructs, nullptr, false, &status);
int32_t bufLen = (int32_t)uprv_strlen(buffer); if(bufferCapacity<bufLen) { /* The capacity is less than the length?! Is this NUL terminated? */
*status = U_ILLEGAL_ARGUMENT_ERROR; return 0;
}
char* keywords = const_cast<char*>(locale_getKeywordsStart(buffer));
int32_t baseLen = keywords == nullptr ? bufLen : keywords - buffer; // Remove -1 from the capacity so that this function can guarantee NUL termination.
CheckedArrayByteSink sink(keywords == nullptr ? buffer + bufLen : keywords,
bufferCapacity - baseLen - 1);
int32_t reslen = ulocimp_setKeywordValue(
keywords == nullptr ? std::string_view() : keywords,
keywordName,
keywordValue == nullptr ? std::string_view() : keywordValue,
sink,
*status);
// See the documentation for this function, it's guaranteed to never // overflow the buffer but instead abort with BUFFER_OVERFLOW_ERROR. // In this case, nothing has been written to the sink, so it cannot have Overflowed().
U_ASSERT(!sink.Overflowed());
U_ASSERT(reslen >= 0); return u_terminateChars(buffer, bufferCapacity, reslen + baseLen, status);
}
U_EXPORT void
ulocimp_setKeywordValue(std::string_view keywordName,
std::string_view keywordValue,
CharString& localeID,
UErrorCode& status)
{ if (U_FAILURE(status)) { return; }
std::string_view keywords; if (constchar* start = locale_getKeywordsStart(localeID.data()); start != nullptr) { // This is safe because CharString::truncate() doesn't actually erase any // data, but simply sets the position for where new data will be written.
int32_t size = start - localeID.data();
keywords = localeID.toStringPiece();
keywords.remove_prefix(size);
localeID.truncate(size);
}
CharStringByteSink sink(&localeID);
ulocimp_setKeywordValue(keywords, keywordName, keywordValue, sink, status);
}
if (status == U_STRING_NOT_TERMINATED_WARNING) {
status = U_ZERO_ERROR;
} if (keywordName.empty()) {
status = U_ILLEGAL_ARGUMENT_ERROR; return 0;
}
CharString canonKeywordName = locale_canonKeywordName(keywordName, status); if (U_FAILURE(status)) { return 0;
}
CharString canonKeywordValue; for (char c : keywordValue) { if (!UPRV_ISALPHANUM(c) && !UPRV_OK_VALUE_PUNCTUATION(c)) {
status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed key value */ return 0;
} /* Should we force lowercase in value to set? */
canonKeywordValue.append(c, status);
} if (U_FAILURE(status)) { return 0;
}
if (keywords.size() <= 1) { if (canonKeywordValue.isEmpty()) { /* no keywords = nothing to remove */
U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING); return 0;
}
/* start processing the value part */
nextEqualsign++; /* skip '=' */ /* First strip leading & trailing spaces (TC decided to tolerate these) */ while (nextEqualsign < keywords.size() && keywords[nextEqualsign] == ' ') {
nextEqualsign++;
}
keyValueTail = nextSeparator == std::string_view::npos ? keywords.size() : nextSeparator; while (keyValueTail > nextEqualsign && keywords[keyValueTail - 1] == ' ') {
keyValueTail--;
} if (nextEqualsign == keyValueTail) {
status = U_ILLEGAL_ARGUMENT_ERROR; /* empty key value in passed-in locale */ return 0;
}
rc = uprv_strcmp(canonKeywordName.data(), localeKeywordName.data()); if(rc == 0) { /* Current entry matches the input keyword. Update the entry */ if (!canonKeywordValue.isEmpty()) { /* updating a value */
updatedKeysAndValues.append(keyValuePrefix, status);
keyValuePrefix = ';'; /* for any subsequent key-value pair */
updatedKeysAndValues.append(canonKeywordName, status);
updatedKeysAndValues.append('=', status);
updatedKeysAndValues.append(canonKeywordValue, status);
} /* else removing this entry, don't emit anything */
handledInputKeyAndValue = true;
} else { /* input keyword sorts earlier than current entry, add before current entry */ if (rc < 0 && !canonKeywordValue.isEmpty() && !handledInputKeyAndValue) { /* insert new entry at this location */
updatedKeysAndValues.append(keyValuePrefix, status);
keyValuePrefix = ';'; /* for any subsequent key-value pair */
updatedKeysAndValues.append(canonKeywordName, status);
updatedKeysAndValues.append('=', status);
updatedKeysAndValues.append(canonKeywordValue, status);
handledInputKeyAndValue = true;
} /* copy the current entry */
updatedKeysAndValues.append(keyValuePrefix, status);
keyValuePrefix = ';'; /* for any subsequent key-value pair */
updatedKeysAndValues.append(localeKeywordName, status);
updatedKeysAndValues.append('=', status);
updatedKeysAndValues.append(keywords.data() + nextEqualsign, static_cast<int32_t>(keyValueTail - nextEqualsign), status);
} if (nextSeparator == std::string_view::npos && !canonKeywordValue.isEmpty() && !handledInputKeyAndValue) { /* append new entry at the end, it sorts later than existing entries */
updatedKeysAndValues.append(keyValuePrefix, status); /* skip keyValuePrefix update, no subsequent key-value pair */
updatedKeysAndValues.append(canonKeywordName, status);
updatedKeysAndValues.append('=', status);
updatedKeysAndValues.append(canonKeywordValue, status);
handledInputKeyAndValue = true;
}
keywordStart = nextSeparator;
} /* end loop searching */
/* Any error from updatedKeysAndValues.append above would be internal and not due to * problems with the passed-in locale. So if we did encounter problems with the * passed-in locale above, those errors took precedence and overrode any error * status from updatedKeysAndValues.append, and also caused a return of 0. If there * are errors here they are from updatedKeysAndValues.append; they do cause an * error return but the passed-in locale is unmodified and the original bufLen is * returned.
*/ if (!handledInputKeyAndValue || U_FAILURE(status)) { /* if input key/value specified removal of a keyword not present in locale, or
* there was an error in CharString.append, leave original locale alone. */
U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING); returnstatic_cast<int32_t>(keywords.size());
}
needLen = updatedKeysAndValues.length(); // Check to see can we fit the updatedKeysAndValues, if not, return // U_BUFFER_OVERFLOW_ERROR without copy updatedKeysAndValues into it. // We do this because this API function does not behave like most others: // It promises never to set a U_STRING_NOT_TERMINATED_WARNING. // When the contents fits but without the terminating NUL, in this case we need to not change // the buffer contents and return with a buffer overflow error. if (needLen > 0) {
int32_t capacity = 0; char* buffer = sink.GetAppendBuffer(
needLen, needLen, nullptr, needLen, &capacity); if (capacity < needLen || buffer == nullptr) {
status = U_BUFFER_OVERFLOW_ERROR; return needLen;
}
uprv_memcpy(buffer, updatedKeysAndValues.data(), needLen);
sink.Append(buffer, needLen);
}
U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING); return needLen;
}
/* ### ID parsing implementation **************************************************/
namespace {
inlinebool _isPrefixLetter(char a) { return a == 'x' || a == 'X' || a == 'i' || a == 'I'; }
/*returns true if one of the special prefixes is here (s=string)
'x-' or 'i-' */ inlinebool _isIDPrefix(constchar *s) { return _isPrefixLetter(s[0]) && _isIDSeparator(s[1]); }
/* Dot terminates it because of POSIX form where dot precedes the codepage * except for variant
*/ inlinebool _isTerminator(char a) { return a == 0 || a == '.' || a == '@'; }
/** * Lookup 'key' in the array 'list'. The array 'list' should contain * a nullptr entry, followed by more entries, and a second nullptr entry. * * The 'list' param should be LANGUAGES, LANGUAGES_3, COUNTRIES, or * COUNTRIES_3.
*/
std::optional<int16_t> _findIndex(constchar* const* list, constchar* key)
{ constchar* const* anchor = list;
int32_t pass = 0;
/* Make two passes through two nullptr-terminated arrays at 'list' */ while (pass++ < 2) { while (*list) { if (uprv_strcmp(key, *list) == 0) { returnstatic_cast<int16_t>(list - anchor);
}
list++;
}
++list; /* skip final nullptr *CWB*/
} return std::nullopt;
}
/* * the internal functions _getLanguage(), _getScript(), _getRegion(), _getVariant() * avoid duplicating code to handle the earlier locale ID pieces * in the functions for the later ones by * setting the *pEnd pointer to where they stopped parsing * * TODO try to use this in Locale
*/
constexpr int32_t MAXLEN = ULOC_LANG_CAPACITY - 1; // Minus NUL.
/* if it starts with i- or x- then copy that prefix */
int32_t len = _isIDPrefix(localeID) ? 2 : 0; while (!_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len])) { if (len == MAXLEN) {
status = U_ILLEGAL_ARGUMENT_ERROR; return;
}
len++;
}
*pEnd = localeID + len; if (sink == nullptr || len == 0) { return; }
for (int32_t i = 0; i < len; ++i) {
buffer[i] = uprv_toupper(localeID[i]);
}
if (len == 3) { /* convert 3 character code to 2 character code if possible *CWB*/
U_ASSERT(capacity >= 4);
buffer[3] = '\0';
std::optional<int16_t> offset = _findIndex(COUNTRIES_3, buffer); if (offset.has_value()) { constchar* const alias = COUNTRIES[*offset];
sink->Append(alias, static_cast<int32_t>(uprv_strlen(alias))); return;
}
}
sink->Append(buffer, len);
}
/** * @param needSeparator if true, then add leading '_' if any variants * are added to 'variant'
*/ void
_getVariant(constchar* localeID, char prev,
ByteSink* sink, constchar** pEnd, bool needSeparator,
UErrorCode& status) { if (U_FAILURE(status)) return; if (pEnd != nullptr) { *pEnd = localeID; }
// Reasonable upper limit for variants // There are no strict limitation of the syntax of variant in the legacy // locale format. If the locale is constructed from unicode_locale_id // as defined in UTS35, then we know each unicode_variant_subtag // could have max length of 8 ((alphanum{5,8} | digit alphanum{3}) // 179 would allow 20 unicode_variant_subtag with sep in the // unicode_locale_id // 8*20 + 1*(20-1) = 179
constexpr int32_t MAX_VARIANTS_LENGTH = 179;
/* get one or more variant tags and separate them with '_' */
int32_t index = 0; if (_isIDSeparator(prev)) { /* get a variant string after a '-' or '_' */ for (index=0; !_isTerminator(localeID[index]); index++) { if (index >= MAX_VARIANTS_LENGTH) { // same as length > MAX_VARIANTS_LENGTH
status = U_ILLEGAL_ARGUMENT_ERROR; return;
} if (needSeparator) { if (sink != nullptr) {
sink->Append("_", 1);
}
needSeparator = false;
} if (sink != nullptr) { char c = uprv_toupper(localeID[index]); if (c == '-') c = '_';
sink->Append(&c, 1);
}
} if (pEnd != nullptr) { *pEnd = localeID+index; }
}
/* if there is no variant tag after a '-' or '_' then look for '@' */ if (index == 0) { if (prev=='@') { /* keep localeID */
} elseif((localeID=locale_getKeywordsStart(localeID))!=nullptr) {
++localeID; /* point after the '@' */
} else { return;
} for(; !_isTerminator(localeID[index]); index++) { if (index >= MAX_VARIANTS_LENGTH) { // same as length > MAX_VARIANTS_LENGTH
status = U_ILLEGAL_ARGUMENT_ERROR; return;
} if (needSeparator) { if (sink != nullptr) {
sink->Append("_", 1);
}
needSeparator = false;
} if (sink != nullptr) { char c = uprv_toupper(localeID[index]); if (c == '-' || c == ',') c = '_';
sink->Append(&c, 1);
}
} if (pEnd != nullptr) { *pEnd = localeID + index; }
}
}
if (_isIDSeparator(*localeID) && !_isBCP47Extension(localeID)) { /* If there was no country ID, skip a possible extra IDSeparator */ if (!hasRegion && _isIDSeparator(localeID[1])) {
localeID++;
} constchar* begin = localeID + 1; constchar* end = nullptr;
_getVariant(begin, *localeID, variant, &end, false, status); if (U_FAILURE(status)) { return; }
U_ASSERT(end != nullptr); if (end != begin && pEnd != nullptr) { *pEnd = end; }
}
}
/** * Canonicalize the given localeID, to level 1 or to level 2, * depending on the options. To specify level 1, pass in options=0. * To specify level 2, pass in options=_ULOC_CANONICALIZE. * * This is the code underlying uloc_getName and uloc_canonicalize.
*/ void
_canonicalize(constchar* localeID,
ByteSink& sink,
uint32_t options,
UErrorCode& err) { if (U_FAILURE(err)) { return;
}
int32_t j, fieldCount=0;
CharString tempBuffer; // if localeID has a BCP47 extension, tmpLocaleID points to this
CharString localeIDWithHyphens; // if localeID has a BPC47 extension and have _, tmpLocaleID points to this constchar* origLocaleID; constchar* tmpLocaleID; constchar* keywordAssign = nullptr; constchar* separatorIndicator = nullptr;
if (_hasBCP47Extension(localeID)) { constchar* localeIDPtr = localeID;
// convert all underbars to hyphens, unless the "BCP47 extension" comes at the beginning of the string if (uprv_strchr(localeID, '_') != nullptr && localeID[1] != '-' && localeID[1] != '_') {
localeIDWithHyphens.append(localeID, -1, err); if (U_SUCCESS(err)) { for (char* p = localeIDWithHyphens.data(); *p != '\0'; ++p) { if (*p == '_') {
*p = '-';
}
}
localeIDPtr = localeIDWithHyphens.data();
}
}
/* get all pieces, one after another, and separate with '_' */
CharString tag;
CharString script;
CharString country;
CharString variant;
ulocimp_getSubtags(
tmpLocaleID,
&tag,
&script,
&country,
&variant,
&tmpLocaleID,
err); if (U_FAILURE(err)) { return;
}
/* Copy POSIX-style charset specifier, if any [mr.utf8] */ if (!OPTION_SET(options, _ULOC_CANONICALIZE) && *tmpLocaleID == '.') {
tag.append('.', err);
++tmpLocaleID; constchar *atPos = nullptr;
size_t length; if((atPos = uprv_strchr(tmpLocaleID, '@')) != nullptr) {
length = atPos - tmpLocaleID;
} else {
length = uprv_strlen(tmpLocaleID);
} // The longest charset name we found in IANA charset registry // https://www.iana.org/assignments/character-sets/ is // "Extended_UNIX_Code_Packed_Format_for_Japanese" in length 45. // we therefore restrict the length here to be 64 which is a power of 2 // number that is longer than 45.
constexpr size_t kMaxCharsetLength = 64; if (length > kMaxCharsetLength) {
err = U_ILLEGAL_ARGUMENT_ERROR; /* malformed keyword name */ return;
}
tag.append(tmpLocaleID, static_cast<int32_t>(length), err);
tmpLocaleID += length;
}
/* Scan ahead to next '@' and determine if it is followed by '=' and/or ';'
After this, tmpLocaleID either points to '@' or is nullptr */ if ((tmpLocaleID=locale_getKeywordsStart(tmpLocaleID))!=nullptr) {
keywordAssign = uprv_strchr(tmpLocaleID, '=');
separatorIndicator = uprv_strchr(tmpLocaleID, ';');
}
/* Copy POSIX-style variant, if any [mr@FOO] */ if (!OPTION_SET(options, _ULOC_CANONICALIZE) &&
tmpLocaleID != nullptr && keywordAssign == nullptr) { for (;;) { char c = *tmpLocaleID; if (c == 0) { break;
}
tag.append(c, err);
++tmpLocaleID;
}
}
if (OPTION_SET(options, _ULOC_CANONICALIZE)) { /* Handle @FOO variant if @ is present and not followed by = */ if (tmpLocaleID!=nullptr && keywordAssign==nullptr) { /* Add missing '_' if needed */ if (fieldCount < 2 || (fieldCount < 3 && !script.isEmpty())) { do {
tag.append('_', err);
++fieldCount;
} while(fieldCount<2);
}
/* Check for incomplete id. */ if (!localeID || uprv_strlen(localeID) < 2) { return 0;
}
// First, attempt Windows platform lookup if available, but fall // through to catch any special cases (ICU vs Windows name differences).
lcid = uprv_convertToLCIDPlatform(localeID, &status); if (U_FAILURE(status)) { return 0;
} if (lcid > 0) { // Windows found an LCID, return that return lcid;
}
U_CAPI void U_EXPORT2
uloc_setDefault(constchar* newDefaultLocale,
UErrorCode* err)
{ if (U_FAILURE(*err)) return; /* the error code isn't currently used for anything by this function*/
/* propagate change to C++ */
locale_set_default(newDefaultLocale);
}
/** * Returns a list of all 2-letter language codes defined in ISO 639. This is a pointer * to an array of pointers to arrays of char. All of these pointers are owned * by ICU-- do not delete them, and do not write through them. The array is * terminated with a null pointer.
*/
U_CAPI constchar* const* U_EXPORT2
uloc_getISOLanguages()
{ return LANGUAGES;
}
/** * Returns a list of all 2-letter country codes defined in ISO 639. This is a * pointer to an array of pointers to arrays of char. All of these pointers are * owned by ICU-- do not delete them, and do not write through them. The array is * terminated with a null pointer.
*/
U_CAPI constchar* const* U_EXPORT2
uloc_getISOCountries()
{ return COUNTRIES;
}
U_CAPI constchar* U_EXPORT2
uloc_toUnicodeLocaleKey(constchar* keyword)
{ if (keyword == nullptr || *keyword == '\0') { return nullptr; }
std::optional<std::string_view> result = ulocimp_toBcpKeyWithFallback(keyword); return result.has_value() ? result->data() : nullptr; // Known to be NUL terminated.
}
U_EXPORT std::optional<std::string_view>
ulocimp_toBcpKeyWithFallback(std::string_view keyword)
{
std::optional<std::string_view> bcpKey = ulocimp_toBcpKey(keyword); if (!bcpKey.has_value() &&
ultag_isUnicodeLocaleKey(keyword.data(), static_cast<int32_t>(keyword.size()))) { // unknown keyword, but syntax is fine.. return keyword;
} return bcpKey;
}
U_CAPI constchar* U_EXPORT2
uloc_toUnicodeLocaleType(constchar* keyword, constchar* value)
{ if (keyword == nullptr || *keyword == '\0' ||
value == nullptr || *value == '\0') { return nullptr; }
std::optional<std::string_view> result = ulocimp_toBcpTypeWithFallback(keyword, value); return result.has_value() ? result->data() : nullptr; // Known to be NUL terminated.
}
bool
isWellFormedLegacyType(std::string_view legacyType)
{
int32_t alphaNumLen = 0; for (char c : legacyType) { if (c == '_' || c == '/' || c == '-') { if (alphaNumLen == 0) { returnfalse;
}
alphaNumLen = 0;
} elseif (UPRV_ISALPHANUM(c)) {
alphaNumLen++;
} else { returnfalse;
}
} return alphaNumLen != 0;
}
} // namespace
U_CAPI constchar* U_EXPORT2
uloc_toLegacyKey(constchar* keyword)
{ if (keyword == nullptr || *keyword == '\0') { return nullptr; }
std::optional<std::string_view> result = ulocimp_toLegacyKeyWithFallback(keyword); return result.has_value() ? result->data() : nullptr; // Known to be NUL terminated.
}
U_EXPORT std::optional<std::string_view>
ulocimp_toLegacyKeyWithFallback(std::string_view keyword)
{
std::optional<std::string_view> legacyKey = ulocimp_toLegacyKey(keyword); if (!legacyKey.has_value() && isWellFormedLegacyKey(keyword)) { // Checks if the specified locale key is well-formed with the legacy locale syntax. // // Note: // LDML/CLDR provides some definition of keyword syntax in // * http://www.unicode.org/reports/tr35/#Unicode_locale_identifier and // * http://www.unicode.org/reports/tr35/#Old_Locale_Extension_Syntax // Keys can only consist of [0-9a-zA-Z]. return keyword;
} return legacyKey;
}
U_CAPI constchar* U_EXPORT2
uloc_toLegacyType(constchar* keyword, constchar* value)
{ if (keyword == nullptr || *keyword == '\0' ||
value == nullptr || *value == '\0') { return nullptr; }
std::optional<std::string_view> result = ulocimp_toLegacyTypeWithFallback(keyword, value); return result.has_value() ? result->data() : nullptr; // Known to be NUL terminated.
}
U_EXPORT std::optional<std::string_view>
ulocimp_toLegacyTypeWithFallback(std::string_view keyword, std::string_view value)
{
std::optional<std::string_view> legacyType = ulocimp_toLegacyType(keyword, value); if (!legacyType.has_value() && isWellFormedLegacyType(value)) { // Checks if the specified locale type is well-formed with the legacy locale syntax. // // Note: // LDML/CLDR provides some definition of keyword syntax in // * http://www.unicode.org/reports/tr35/#Unicode_locale_identifier and // * http://www.unicode.org/reports/tr35/#Old_Locale_Extension_Syntax // Values (types) can only consist of [0-9a-zA-Z], plus for legacy values // we allow [/_-+] in the middle (e.g. "Etc/GMT+1", "Asia/Tel_Aviv") return value;
} return legacyType;
}
/*eof*/
Messung V0.5 in Prozent
¤ Dauer der Verarbeitung: 0.75 Sekunden
(vorverarbeitet am 2026-04-28)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
