| // © 2019 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| #include <utility> | |
| #include "bytesinkutil.h" // CharStringByteSink | |
| #include "charstr.h" | |
| #include "cstring.h" | |
| #include "ulocimp.h" | |
| #include "unicode/localebuilder.h" | |
| #include "unicode/locid.h" | |
| U_NAMESPACE_BEGIN | |
| #define UPRV_ISDIGIT(c) (((c) >= '0') && ((c) <= '9')) | |
| #define UPRV_ISALPHANUM(c) (uprv_isASCIILetter(c) || UPRV_ISDIGIT(c) ) | |
| const char* kAttributeKey = "attribute"; | |
| static bool _isExtensionSubtags(char key, const char* s, int32_t len) { | |
| switch (uprv_tolower(key)) { | |
| case 'u': | |
| return ultag_isUnicodeExtensionSubtags(s, len); | |
| case 't': | |
| return ultag_isTransformedExtensionSubtags(s, len); | |
| case 'x': | |
| return ultag_isPrivateuseValueSubtags(s, len); | |
| default: | |
| return ultag_isExtensionSubtags(s, len); | |
| } | |
| } | |
| LocaleBuilder::LocaleBuilder() : UObject(), status_(U_ZERO_ERROR), language_(), | |
| script_(), region_(), variant_(nullptr), extensions_(nullptr) | |
| { | |
| language_[0] = 0; | |
| script_[0] = 0; | |
| region_[0] = 0; | |
| } | |
| LocaleBuilder::~LocaleBuilder() | |
| { | |
| delete variant_; | |
| delete extensions_; | |
| } | |
| LocaleBuilder& LocaleBuilder::setLocale(const Locale& locale) | |
| { | |
| clear(); | |
| setLanguage(locale.getLanguage()); | |
| setScript(locale.getScript()); | |
| setRegion(locale.getCountry()); | |
| setVariant(locale.getVariant()); | |
| extensions_ = locale.clone(); | |
| if (extensions_ == nullptr) { | |
| status_ = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::setLanguageTag(StringPiece tag) | |
| { | |
| Locale l = Locale::forLanguageTag(tag, status_); | |
| if (U_FAILURE(status_)) { return *this; } | |
| // Because setLocale will reset status_ we need to return | |
| // first if we have error in forLanguageTag. | |
| setLocale(l); | |
| return *this; | |
| } | |
| static void setField(StringPiece input, char* dest, UErrorCode& errorCode, | |
| UBool (*test)(const char*, int32_t)) { | |
| if (U_FAILURE(errorCode)) { return; } | |
| if (input.empty()) { | |
| dest[0] = '\0'; | |
| } else if (test(input.data(), input.length())) { | |
| uprv_memcpy(dest, input.data(), input.length()); | |
| dest[input.length()] = '\0'; | |
| } else { | |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| } | |
| LocaleBuilder& LocaleBuilder::setLanguage(StringPiece language) | |
| { | |
| setField(language, language_, status_, &ultag_isLanguageSubtag); | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::setScript(StringPiece script) | |
| { | |
| setField(script, script_, status_, &ultag_isScriptSubtag); | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::setRegion(StringPiece region) | |
| { | |
| setField(region, region_, status_, &ultag_isRegionSubtag); | |
| return *this; | |
| } | |
| static void transform(char* data, int32_t len) { | |
| for (int32_t i = 0; i < len; i++, data++) { | |
| if (*data == '_') { | |
| *data = '-'; | |
| } else { | |
| *data = uprv_tolower(*data); | |
| } | |
| } | |
| } | |
| LocaleBuilder& LocaleBuilder::setVariant(StringPiece variant) | |
| { | |
| if (U_FAILURE(status_)) { return *this; } | |
| if (variant.empty()) { | |
| delete variant_; | |
| variant_ = nullptr; | |
| return *this; | |
| } | |
| CharString* new_variant = new CharString(variant, status_); | |
| if (U_FAILURE(status_)) { return *this; } | |
| if (new_variant == nullptr) { | |
| status_ = U_MEMORY_ALLOCATION_ERROR; | |
| return *this; | |
| } | |
| transform(new_variant->data(), new_variant->length()); | |
| if (!ultag_isVariantSubtags(new_variant->data(), new_variant->length())) { | |
| delete new_variant; | |
| status_ = U_ILLEGAL_ARGUMENT_ERROR; | |
| return *this; | |
| } | |
| delete variant_; | |
| variant_ = new_variant; | |
| return *this; | |
| } | |
| static bool | |
| _isKeywordValue(const char* key, const char* value, int32_t value_len) | |
| { | |
| if (key[1] == '\0') { | |
| // one char key | |
| return (UPRV_ISALPHANUM(uprv_tolower(key[0])) && | |
| _isExtensionSubtags(key[0], value, value_len)); | |
| } else if (uprv_strcmp(key, kAttributeKey) == 0) { | |
| // unicode attributes | |
| return ultag_isUnicodeLocaleAttributes(value, value_len); | |
| } | |
| // otherwise: unicode extension value | |
| // We need to convert from legacy key/value to unicode | |
| // key/value | |
| const char* unicode_locale_key = uloc_toUnicodeLocaleKey(key); | |
| const char* unicode_locale_type = uloc_toUnicodeLocaleType(key, value); | |
| return unicode_locale_key && unicode_locale_type && | |
| ultag_isUnicodeLocaleKey(unicode_locale_key, -1) && | |
| ultag_isUnicodeLocaleType(unicode_locale_type, -1); | |
| } | |
| static void | |
| _copyExtensions(const Locale& from, icu::StringEnumeration *keywords, | |
| Locale& to, bool validate, UErrorCode& errorCode) | |
| { | |
| if (U_FAILURE(errorCode)) { return; } | |
| LocalPointer<icu::StringEnumeration> ownedKeywords; | |
| if (keywords == nullptr) { | |
| ownedKeywords.adoptInstead(from.createKeywords(errorCode)); | |
| if (U_FAILURE(errorCode) || ownedKeywords.isNull()) { return; } | |
| keywords = ownedKeywords.getAlias(); | |
| } | |
| const char* key; | |
| while ((key = keywords->next(nullptr, errorCode)) != nullptr) { | |
| CharString value; | |
| CharStringByteSink sink(&value); | |
| from.getKeywordValue(key, sink, errorCode); | |
| if (U_FAILURE(errorCode)) { return; } | |
| if (uprv_strcmp(key, kAttributeKey) == 0) { | |
| transform(value.data(), value.length()); | |
| } | |
| if (validate && | |
| !_isKeywordValue(key, value.data(), value.length())) { | |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| to.setKeywordValue(key, value.data(), errorCode); | |
| if (U_FAILURE(errorCode)) { return; } | |
| } | |
| } | |
| void static | |
| _clearUAttributesAndKeyType(Locale& locale, UErrorCode& errorCode) | |
| { | |
| // Clear Unicode attributes | |
| locale.setKeywordValue(kAttributeKey, "", errorCode); | |
| // Clear all Unicode keyword values | |
| LocalPointer<icu::StringEnumeration> iter(locale.createUnicodeKeywords(errorCode)); | |
| if (U_FAILURE(errorCode) || iter.isNull()) { return; } | |
| const char* key; | |
| while ((key = iter->next(nullptr, errorCode)) != nullptr) { | |
| locale.setUnicodeKeywordValue(key, nullptr, errorCode); | |
| } | |
| } | |
| static void | |
| _setUnicodeExtensions(Locale& locale, const CharString& value, UErrorCode& errorCode) | |
| { | |
| // Add the unicode extensions to extensions_ | |
| CharString locale_str("und-u-", errorCode); | |
| locale_str.append(value, errorCode); | |
| _copyExtensions( | |
| Locale::forLanguageTag(locale_str.data(), errorCode), nullptr, | |
| locale, false, errorCode); | |
| } | |
| LocaleBuilder& LocaleBuilder::setExtension(char key, StringPiece value) | |
| { | |
| if (U_FAILURE(status_)) { return *this; } | |
| if (!UPRV_ISALPHANUM(key)) { | |
| status_ = U_ILLEGAL_ARGUMENT_ERROR; | |
| return *this; | |
| } | |
| CharString value_str(value, status_); | |
| if (U_FAILURE(status_)) { return *this; } | |
| transform(value_str.data(), value_str.length()); | |
| if (!value_str.isEmpty() && | |
| !_isExtensionSubtags(key, value_str.data(), value_str.length())) { | |
| status_ = U_ILLEGAL_ARGUMENT_ERROR; | |
| return *this; | |
| } | |
| if (extensions_ == nullptr) { | |
| extensions_ = new Locale(); | |
| if (extensions_ == nullptr) { | |
| status_ = U_MEMORY_ALLOCATION_ERROR; | |
| return *this; | |
| } | |
| } | |
| if (uprv_tolower(key) != 'u') { | |
| // for t, x and others extension. | |
| extensions_->setKeywordValue(StringPiece(&key, 1), value_str.data(), | |
| status_); | |
| return *this; | |
| } | |
| _clearUAttributesAndKeyType(*extensions_, status_); | |
| if (U_FAILURE(status_)) { return *this; } | |
| if (!value.empty()) { | |
| _setUnicodeExtensions(*extensions_, value_str, status_); | |
| } | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::setUnicodeLocaleKeyword( | |
| StringPiece key, StringPiece type) | |
| { | |
| if (U_FAILURE(status_)) { return *this; } | |
| if (!ultag_isUnicodeLocaleKey(key.data(), key.length()) || | |
| (!type.empty() && | |
| !ultag_isUnicodeLocaleType(type.data(), type.length()))) { | |
| status_ = U_ILLEGAL_ARGUMENT_ERROR; | |
| return *this; | |
| } | |
| if (extensions_ == nullptr) { | |
| extensions_ = new Locale(); | |
| } | |
| if (extensions_ == nullptr) { | |
| status_ = U_MEMORY_ALLOCATION_ERROR; | |
| return *this; | |
| } | |
| extensions_->setUnicodeKeywordValue(key, type, status_); | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::addUnicodeLocaleAttribute( | |
| StringPiece value) | |
| { | |
| CharString value_str(value, status_); | |
| if (U_FAILURE(status_)) { return *this; } | |
| transform(value_str.data(), value_str.length()); | |
| if (!ultag_isUnicodeLocaleAttribute(value_str.data(), value_str.length())) { | |
| status_ = U_ILLEGAL_ARGUMENT_ERROR; | |
| return *this; | |
| } | |
| if (extensions_ == nullptr) { | |
| extensions_ = new Locale(); | |
| if (extensions_ == nullptr) { | |
| status_ = U_MEMORY_ALLOCATION_ERROR; | |
| return *this; | |
| } | |
| extensions_->setKeywordValue(kAttributeKey, value_str.data(), status_); | |
| return *this; | |
| } | |
| CharString attributes; | |
| CharStringByteSink sink(&attributes); | |
| UErrorCode localErrorCode = U_ZERO_ERROR; | |
| extensions_->getKeywordValue(kAttributeKey, sink, localErrorCode); | |
| if (U_FAILURE(localErrorCode)) { | |
| CharString new_attributes(value_str.data(), status_); | |
| // No attributes, set the attribute. | |
| extensions_->setKeywordValue(kAttributeKey, new_attributes.data(), status_); | |
| return *this; | |
| } | |
| transform(attributes.data(),attributes.length()); | |
| const char* start = attributes.data(); | |
| const char* limit = attributes.data() + attributes.length(); | |
| CharString new_attributes; | |
| bool inserted = false; | |
| while (start < limit) { | |
| if (!inserted) { | |
| int cmp = uprv_strcmp(start, value_str.data()); | |
| if (cmp == 0) { return *this; } // Found it in attributes: Just return | |
| if (cmp > 0) { | |
| if (!new_attributes.isEmpty()) new_attributes.append('_', status_); | |
| new_attributes.append(value_str.data(), status_); | |
| inserted = true; | |
| } | |
| } | |
| if (!new_attributes.isEmpty()) { | |
| new_attributes.append('_', status_); | |
| } | |
| new_attributes.append(start, status_); | |
| start += uprv_strlen(start) + 1; | |
| } | |
| if (!inserted) { | |
| if (!new_attributes.isEmpty()) { | |
| new_attributes.append('_', status_); | |
| } | |
| new_attributes.append(value_str.data(), status_); | |
| } | |
| // Not yet in the attributes, set the attribute. | |
| extensions_->setKeywordValue(kAttributeKey, new_attributes.data(), status_); | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::removeUnicodeLocaleAttribute( | |
| StringPiece value) | |
| { | |
| CharString value_str(value, status_); | |
| if (U_FAILURE(status_)) { return *this; } | |
| transform(value_str.data(), value_str.length()); | |
| if (!ultag_isUnicodeLocaleAttribute(value_str.data(), value_str.length())) { | |
| status_ = U_ILLEGAL_ARGUMENT_ERROR; | |
| return *this; | |
| } | |
| if (extensions_ == nullptr) { return *this; } | |
| UErrorCode localErrorCode = U_ZERO_ERROR; | |
| CharString attributes; | |
| CharStringByteSink sink(&attributes); | |
| extensions_->getKeywordValue(kAttributeKey, sink, localErrorCode); | |
| // get failure, just return | |
| if (U_FAILURE(localErrorCode)) { return *this; } | |
| // Do not have any attributes, just return. | |
| if (attributes.isEmpty()) { return *this; } | |
| char* p = attributes.data(); | |
| // Replace null terminiator in place for _ and - so later | |
| // we can use uprv_strcmp to compare. | |
| for (int32_t i = 0; i < attributes.length(); i++, p++) { | |
| *p = (*p == '_' || *p == '-') ? '\0' : uprv_tolower(*p); | |
| } | |
| const char* start = attributes.data(); | |
| const char* limit = attributes.data() + attributes.length(); | |
| CharString new_attributes; | |
| bool found = false; | |
| while (start < limit) { | |
| if (uprv_strcmp(start, value_str.data()) == 0) { | |
| found = true; | |
| } else { | |
| if (!new_attributes.isEmpty()) { | |
| new_attributes.append('_', status_); | |
| } | |
| new_attributes.append(start, status_); | |
| } | |
| start += uprv_strlen(start) + 1; | |
| } | |
| // Found the value in attributes, set the attribute. | |
| if (found) { | |
| extensions_->setKeywordValue(kAttributeKey, new_attributes.data(), status_); | |
| } | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::clear() | |
| { | |
| status_ = U_ZERO_ERROR; | |
| language_[0] = 0; | |
| script_[0] = 0; | |
| region_[0] = 0; | |
| delete variant_; | |
| variant_ = nullptr; | |
| clearExtensions(); | |
| return *this; | |
| } | |
| LocaleBuilder& LocaleBuilder::clearExtensions() | |
| { | |
| delete extensions_; | |
| extensions_ = nullptr; | |
| return *this; | |
| } | |
| Locale makeBogusLocale() { | |
| Locale bogus; | |
| bogus.setToBogus(); | |
| return bogus; | |
| } | |
| void LocaleBuilder::copyExtensionsFrom(const Locale& src, UErrorCode& errorCode) | |
| { | |
| if (U_FAILURE(errorCode)) { return; } | |
| LocalPointer<icu::StringEnumeration> keywords(src.createKeywords(errorCode)); | |
| if (U_FAILURE(errorCode) || keywords.isNull() || keywords->count(errorCode) == 0) { | |
| // Error, or no extensions to copy. | |
| return; | |
| } | |
| if (extensions_ == nullptr) { | |
| extensions_ = new Locale(); | |
| if (extensions_ == nullptr) { | |
| status_ = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } | |
| _copyExtensions(src, keywords.getAlias(), *extensions_, false, errorCode); | |
| } | |
| Locale LocaleBuilder::build(UErrorCode& errorCode) | |
| { | |
| if (U_FAILURE(errorCode)) { | |
| return makeBogusLocale(); | |
| } | |
| if (U_FAILURE(status_)) { | |
| errorCode = status_; | |
| return makeBogusLocale(); | |
| } | |
| CharString locale_str(language_, errorCode); | |
| if (uprv_strlen(script_) > 0) { | |
| locale_str.append('-', errorCode).append(StringPiece(script_), errorCode); | |
| } | |
| if (uprv_strlen(region_) > 0) { | |
| locale_str.append('-', errorCode).append(StringPiece(region_), errorCode); | |
| } | |
| if (variant_ != nullptr) { | |
| locale_str.append('-', errorCode).append(StringPiece(variant_->data()), errorCode); | |
| } | |
| if (U_FAILURE(errorCode)) { | |
| return makeBogusLocale(); | |
| } | |
| Locale product(locale_str.data()); | |
| if (extensions_ != nullptr) { | |
| _copyExtensions(*extensions_, nullptr, product, true, errorCode); | |
| } | |
| if (U_FAILURE(errorCode)) { | |
| return makeBogusLocale(); | |
| } | |
| return product; | |
| } | |
| UBool LocaleBuilder::copyErrorTo(UErrorCode &outErrorCode) const { | |
| if (U_FAILURE(outErrorCode)) { | |
| // Do not overwrite the older error code | |
| return TRUE; | |
| } | |
| outErrorCode = status_; | |
| return U_FAILURE(outErrorCode); | |
| } | |
| U_NAMESPACE_END |