| // Copyright 2018 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_INTL_SUPPORT |
| #error Internationalization is expected to be enabled. |
| #endif // V8_INTL_SUPPORT |
| |
| #include "src/objects/js-locale.h" |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "src/api.h" |
| #include "src/global-handles.h" |
| #include "src/heap/factory.h" |
| #include "src/isolate.h" |
| #include "src/objects-inl.h" |
| #include "src/objects/intl-objects.h" |
| #include "src/objects/js-locale-inl.h" |
| #include "unicode/char16ptr.h" |
| #include "unicode/locid.h" |
| #include "unicode/uloc.h" |
| #include "unicode/unistr.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| namespace { |
| |
| JSLocale::CaseFirst GetCaseFirst(const char* str) { |
| if (strcmp(str, "upper") == 0) return JSLocale::CaseFirst::UPPER; |
| if (strcmp(str, "lower") == 0) return JSLocale::CaseFirst::LOWER; |
| if (strcmp(str, "false") == 0) return JSLocale::CaseFirst::FALSE_VALUE; |
| UNREACHABLE(); |
| } |
| |
| JSLocale::HourCycle GetHourCycle(const char* str) { |
| if (strcmp(str, "h11") == 0) return JSLocale::HourCycle::H11; |
| if (strcmp(str, "h12") == 0) return JSLocale::HourCycle::H12; |
| if (strcmp(str, "h23") == 0) return JSLocale::HourCycle::H23; |
| if (strcmp(str, "h24") == 0) return JSLocale::HourCycle::H24; |
| UNREACHABLE(); |
| } |
| |
| JSLocale::Numeric GetNumeric(const char* str) { |
| return strcmp(str, "true") == 0 ? JSLocale::Numeric::TRUE_VALUE |
| : JSLocale::Numeric::FALSE_VALUE; |
| } |
| |
| struct OptionData { |
| const char* name; |
| const char* key; |
| const std::vector<const char*>* possible_values; |
| bool is_bool_value; |
| }; |
| |
| // Inserts tags from options into locale string. |
| Maybe<bool> InsertOptionsIntoLocale(Isolate* isolate, |
| Handle<JSReceiver> options, |
| char* icu_locale) { |
| CHECK(isolate); |
| CHECK(icu_locale); |
| |
| const std::vector<const char*> hour_cycle_values = {"h11", "h12", "h23", |
| "h24"}; |
| const std::vector<const char*> case_first_values = {"upper", "lower", |
| "false"}; |
| const std::vector<const char*> empty_values = {}; |
| const std::array<OptionData, 6> kOptionToUnicodeTagMap = { |
| {{"calendar", "ca", &empty_values, false}, |
| {"collation", "co", &empty_values, false}, |
| {"hourCycle", "hc", &hour_cycle_values, false}, |
| {"caseFirst", "kf", &case_first_values, false}, |
| {"numeric", "kn", &empty_values, true}, |
| {"numberingSystem", "nu", &empty_values, false}}}; |
| |
| // TODO(cira): Pass in values as per the spec to make this to be |
| // spec compliant. |
| |
| for (const auto& option_to_bcp47 : kOptionToUnicodeTagMap) { |
| std::unique_ptr<char[]> value_str = nullptr; |
| bool value_bool = false; |
| Maybe<bool> maybe_found = |
| option_to_bcp47.is_bool_value |
| ? Intl::GetBoolOption(isolate, options, option_to_bcp47.name, |
| "locale", &value_bool) |
| : Intl::GetStringOption(isolate, options, option_to_bcp47.name, |
| *(option_to_bcp47.possible_values), |
| "locale", &value_str); |
| MAYBE_RETURN(maybe_found, Nothing<bool>()); |
| |
| // TODO(cira): Use fallback value if value is not found to make |
| // this spec compliant. |
| if (!maybe_found.FromJust()) continue; |
| |
| if (option_to_bcp47.is_bool_value) { |
| value_str = value_bool ? isolate->factory()->true_string()->ToCString() |
| : isolate->factory()->false_string()->ToCString(); |
| } |
| DCHECK_NOT_NULL(value_str.get()); |
| |
| // Convert bcp47 key and value into legacy ICU format so we can use |
| // uloc_setKeywordValue. |
| const char* key = uloc_toLegacyKey(option_to_bcp47.key); |
| DCHECK_NOT_NULL(key); |
| |
| // Overwrite existing, or insert new key-value to the locale string. |
| const char* value = uloc_toLegacyType(key, value_str.get()); |
| UErrorCode status = U_ZERO_ERROR; |
| if (value) { |
| // TODO(cira): ICU puts artificial limit on locale length, while BCP47 |
| // doesn't. Switch to C++ API when it's ready. |
| // Related ICU bug - https://ssl.icu-project.org/trac/ticket/13417. |
| uloc_setKeywordValue(key, value, icu_locale, ULOC_FULLNAME_CAPACITY, |
| &status); |
| if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) { |
| return Just(false); |
| } |
| } else { |
| return Just(false); |
| } |
| } |
| |
| return Just(true); |
| } |
| |
| // Fills in the JSLocale object slots with Unicode tag/values. |
| bool PopulateLocaleWithUnicodeTags(Isolate* isolate, const char* icu_locale, |
| Handle<JSLocale> locale_holder) { |
| CHECK(isolate); |
| CHECK(icu_locale); |
| |
| Factory* factory = isolate->factory(); |
| |
| UErrorCode status = U_ZERO_ERROR; |
| UEnumeration* keywords = uloc_openKeywords(icu_locale, &status); |
| if (!keywords) return true; |
| |
| char value[ULOC_FULLNAME_CAPACITY]; |
| while (const char* keyword = uenum_next(keywords, nullptr, &status)) { |
| uloc_getKeywordValue(icu_locale, keyword, value, ULOC_FULLNAME_CAPACITY, |
| &status); |
| if (U_FAILURE(status)) { |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| |
| // Ignore those we don't recognize - spec allows that. |
| const char* bcp47_key = uloc_toUnicodeLocaleKey(keyword); |
| if (bcp47_key) { |
| const char* bcp47_value = uloc_toUnicodeLocaleType(bcp47_key, value); |
| if (bcp47_value) { |
| if (strcmp(bcp47_key, "kn") == 0) { |
| locale_holder->set_numeric(GetNumeric(bcp47_value)); |
| } else if (strcmp(bcp47_key, "ca") == 0) { |
| Handle<String> bcp47_handle = |
| factory->NewStringFromAsciiChecked(bcp47_value); |
| locale_holder->set_calendar(*bcp47_handle); |
| } else if (strcmp(bcp47_key, "kf") == 0) { |
| locale_holder->set_case_first(GetCaseFirst(bcp47_value)); |
| } else if (strcmp(bcp47_key, "co") == 0) { |
| Handle<String> bcp47_handle = |
| factory->NewStringFromAsciiChecked(bcp47_value); |
| locale_holder->set_collation(*bcp47_handle); |
| } else if (strcmp(bcp47_key, "hc") == 0) { |
| locale_holder->set_hour_cycle(GetHourCycle(bcp47_value)); |
| } else if (strcmp(bcp47_key, "nu") == 0) { |
| Handle<String> bcp47_handle = |
| factory->NewStringFromAsciiChecked(bcp47_value); |
| locale_holder->set_numbering_system(*bcp47_handle); |
| } |
| } |
| } |
| } |
| |
| uenum_close(keywords); |
| |
| return true; |
| } |
| } // namespace |
| |
| MaybeHandle<JSLocale> JSLocale::Initialize(Isolate* isolate, |
| Handle<JSLocale> locale_holder, |
| Handle<String> locale, |
| Handle<JSReceiver> options) { |
| locale_holder->set_flags(0); |
| static const char* const kMethod = "Intl.Locale"; |
| v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate); |
| UErrorCode status = U_ZERO_ERROR; |
| |
| // Get ICU locale format, and canonicalize it. |
| char icu_result[ULOC_FULLNAME_CAPACITY]; |
| |
| if (locale->length() == 0) { |
| THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kLocaleNotEmpty), |
| JSLocale); |
| } |
| |
| v8::String::Utf8Value bcp47_locale(v8_isolate, v8::Utils::ToLocal(locale)); |
| CHECK_LT(0, bcp47_locale.length()); |
| CHECK_NOT_NULL(*bcp47_locale); |
| |
| int parsed_length = 0; |
| int icu_length = |
| uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY, |
| &parsed_length, &status); |
| |
| if (U_FAILURE(status) || |
| parsed_length < static_cast<int>(bcp47_locale.length()) || |
| status == U_STRING_NOT_TERMINATED_WARNING || icu_length == 0) { |
| THROW_NEW_ERROR( |
| isolate, |
| NewRangeError(MessageTemplate::kLocaleBadParameters, |
| isolate->factory()->NewStringFromAsciiChecked(kMethod), |
| locale_holder), |
| JSLocale); |
| } |
| |
| Maybe<bool> error = InsertOptionsIntoLocale(isolate, options, icu_result); |
| MAYBE_RETURN(error, MaybeHandle<JSLocale>()); |
| if (!error.FromJust()) { |
| THROW_NEW_ERROR( |
| isolate, |
| NewRangeError(MessageTemplate::kLocaleBadParameters, |
| isolate->factory()->NewStringFromAsciiChecked(kMethod), |
| locale_holder), |
| JSLocale); |
| } |
| |
| if (!PopulateLocaleWithUnicodeTags(isolate, icu_result, locale_holder)) { |
| THROW_NEW_ERROR( |
| isolate, |
| NewRangeError(MessageTemplate::kLocaleBadParameters, |
| isolate->factory()->NewStringFromAsciiChecked(kMethod), |
| locale_holder), |
| JSLocale); |
| } |
| |
| // Extract language, script and region parts. |
| char icu_language[ULOC_LANG_CAPACITY]; |
| uloc_getLanguage(icu_result, icu_language, ULOC_LANG_CAPACITY, &status); |
| |
| char icu_script[ULOC_SCRIPT_CAPACITY]; |
| uloc_getScript(icu_result, icu_script, ULOC_SCRIPT_CAPACITY, &status); |
| |
| char icu_region[ULOC_COUNTRY_CAPACITY]; |
| uloc_getCountry(icu_result, icu_region, ULOC_COUNTRY_CAPACITY, &status); |
| |
| if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) { |
| THROW_NEW_ERROR( |
| isolate, |
| NewRangeError(MessageTemplate::kLocaleBadParameters, |
| isolate->factory()->NewStringFromAsciiChecked(kMethod), |
| locale_holder), |
| JSLocale); |
| } |
| |
| Factory* factory = isolate->factory(); |
| |
| // NOTE: One shouldn't use temporary handles, because they can go out of |
| // scope and be garbage collected before properly assigned. |
| // DON'T DO THIS: locale_holder->set_language(*f->NewStringAscii...); |
| Handle<String> language = factory->NewStringFromAsciiChecked(icu_language); |
| locale_holder->set_language(*language); |
| |
| if (strlen(icu_script) != 0) { |
| Handle<String> script = factory->NewStringFromAsciiChecked(icu_script); |
| locale_holder->set_script(*script); |
| } |
| |
| if (strlen(icu_region) != 0) { |
| Handle<String> region = factory->NewStringFromAsciiChecked(icu_region); |
| locale_holder->set_region(*region); |
| } |
| |
| char icu_base_name[ULOC_FULLNAME_CAPACITY]; |
| uloc_getBaseName(icu_result, icu_base_name, ULOC_FULLNAME_CAPACITY, &status); |
| // We need to convert it back to BCP47. |
| char bcp47_result[ULOC_FULLNAME_CAPACITY]; |
| uloc_toLanguageTag(icu_base_name, bcp47_result, ULOC_FULLNAME_CAPACITY, true, |
| &status); |
| if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) { |
| THROW_NEW_ERROR( |
| isolate, |
| NewRangeError(MessageTemplate::kLocaleBadParameters, |
| isolate->factory()->NewStringFromAsciiChecked(kMethod), |
| locale_holder), |
| JSLocale); |
| } |
| Handle<String> base_name = factory->NewStringFromAsciiChecked(bcp47_result); |
| locale_holder->set_base_name(*base_name); |
| |
| // Produce final representation of the locale string, for toString(). |
| uloc_toLanguageTag(icu_result, bcp47_result, ULOC_FULLNAME_CAPACITY, true, |
| &status); |
| if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) { |
| THROW_NEW_ERROR( |
| isolate, |
| NewRangeError(MessageTemplate::kLocaleBadParameters, |
| isolate->factory()->NewStringFromAsciiChecked(kMethod), |
| locale_holder), |
| JSLocale); |
| } |
| Handle<String> locale_handle = |
| factory->NewStringFromAsciiChecked(bcp47_result); |
| locale_holder->set_locale(*locale_handle); |
| |
| return locale_holder; |
| } |
| |
| namespace { |
| Handle<String> MorphLocale(Isolate* isolate, String locale, |
| void (*morph_func)(icu::Locale* l, |
| UErrorCode* status)) { |
| UErrorCode status = U_ZERO_ERROR; |
| icu::Locale icu_locale = |
| icu::Locale::forLanguageTag(locale.ToCString().get(), status); |
| CHECK(U_SUCCESS(status)); |
| CHECK(!icu_locale.isBogus()); |
| (*morph_func)(&icu_locale, &status); |
| CHECK(U_SUCCESS(status)); |
| CHECK(!icu_locale.isBogus()); |
| return isolate->factory()->NewStringFromAsciiChecked( |
| Intl::ToLanguageTag(icu_locale).c_str()); |
| } |
| } // namespace |
| |
| Handle<String> JSLocale::Maximize(Isolate* isolate, String locale) { |
| return MorphLocale(isolate, locale, |
| [](icu::Locale* icu_locale, UErrorCode* status) { |
| icu_locale->addLikelySubtags(*status); |
| }); |
| } |
| |
| Handle<String> JSLocale::Minimize(Isolate* isolate, String locale) { |
| return MorphLocale(isolate, locale, |
| [](icu::Locale* icu_locale, UErrorCode* status) { |
| icu_locale->minimizeSubtags(*status); |
| }); |
| } |
| |
| Handle<String> JSLocale::CaseFirstAsString() const { |
| switch (case_first()) { |
| case CaseFirst::UPPER: |
| return GetReadOnlyRoots().upper_string_handle(); |
| case CaseFirst::LOWER: |
| return GetReadOnlyRoots().lower_string_handle(); |
| case CaseFirst::FALSE_VALUE: |
| return GetReadOnlyRoots().false_string_handle(); |
| case CaseFirst::COUNT: |
| UNREACHABLE(); |
| } |
| } |
| |
| Handle<String> JSLocale::HourCycleAsString() const { |
| switch (hour_cycle()) { |
| case HourCycle::H11: |
| return GetReadOnlyRoots().h11_string_handle(); |
| case HourCycle::H12: |
| return GetReadOnlyRoots().h12_string_handle(); |
| case HourCycle::H23: |
| return GetReadOnlyRoots().h23_string_handle(); |
| case HourCycle::H24: |
| return GetReadOnlyRoots().h24_string_handle(); |
| case HourCycle::COUNT: |
| UNREACHABLE(); |
| } |
| } |
| |
| Handle<String> JSLocale::NumericAsString() const { |
| switch (numeric()) { |
| case Numeric::NOTSET: |
| return GetReadOnlyRoots().undefined_string_handle(); |
| case Numeric::TRUE_VALUE: |
| return GetReadOnlyRoots().true_string_handle(); |
| case Numeric::FALSE_VALUE: |
| return GetReadOnlyRoots().false_string_handle(); |
| case Numeric::COUNT: |
| UNREACHABLE(); |
| } |
| } |
| |
| } // namespace internal |
| } // namespace v8 |
