// 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-relative-time-format.h" #include <map> #include <memory> #include <string> #include "src/execution/isolate.h" #include "src/heap/factory.h" #include "src/objects/intl-objects.h" #include "src/objects/js-number-format.h" #include "src/objects/js-relative-time-format-inl.h" #include "src/objects/managed-inl.h" #include "src/objects/objects-inl.h" #include "src/objects/option-utils.h" #include "unicode/decimfmt.h" #include "unicode/numfmt.h" #include "unicode/reldatefmt.h" #include "unicode/unum.h" namespace v8 { namespace internal { namespace { // Style: identifying the relative time format style used. // // ecma402/#sec-properties-of-intl-relativetimeformat-instances enum class Style { LONG, // Everything spelled out. SHORT, // Abbreviations used when possible. NARROW // Use the shortest possible form. }; UDateRelativeDateTimeFormatterStyle toIcuStyle(Style style) { switch (style) { case Style::LONG: return UDAT_STYLE_LONG; case Style::SHORT: return UDAT_STYLE_SHORT; case Style::NARROW: return UDAT_STYLE_NARROW; } UNREACHABLE(); } Style fromIcuStyle(UDateRelativeDateTimeFormatterStyle icu_style) { switch (icu_style) { case UDAT_STYLE_LONG: return Style::LONG; case UDAT_STYLE_SHORT: return Style::SHORT; case UDAT_STYLE_NARROW: return Style::NARROW; case UDAT_STYLE_COUNT: UNREACHABLE(); } UNREACHABLE(); } } // namespace MaybeHandle<JSRelativeTimeFormat> JSRelativeTimeFormat::New( Isolate* isolate, Handle<Map> map, Handle<Object> locales, Handle<Object> input_options) { // 1. Let requestedLocales be ? CanonicalizeLocaleList(locales). Maybe<std::vector<std::string>> maybe_requested_locales = Intl::CanonicalizeLocaleList(isolate, locales); MAYBE_RETURN(maybe_requested_locales, Handle<JSRelativeTimeFormat>()); std::vector<std::string> requested_locales = maybe_requested_locales.FromJust(); // 2. Set options to ? CoerceOptionsToObject(options). Handle<JSReceiver> options; const char* service = "Intl.RelativeTimeFormat"; ASSIGN_RETURN_ON_EXCEPTION( isolate, options, CoerceOptionsToObject(isolate, input_options, service), JSRelativeTimeFormat); // 4. Let opt be a new Record. // 5. Let matcher be ? GetOption(options, "localeMatcher", "string", « // "lookup", "best fit" », "best fit"). // 6. Set opt.[[localeMatcher]] to matcher. Maybe<Intl::MatcherOption> maybe_locale_matcher = Intl::GetLocaleMatcher(isolate, options, service); MAYBE_RETURN(maybe_locale_matcher, MaybeHandle<JSRelativeTimeFormat>()); Intl::MatcherOption matcher = maybe_locale_matcher.FromJust(); // 7. Let _numberingSystem_ be ? GetOption(_options_, `"numberingSystem"`, // `"string"`, *undefined*, *undefined*). std::unique_ptr<char[]> numbering_system_str = nullptr; Maybe<bool> maybe_numberingSystem = Intl::GetNumberingSystem( isolate, options, service, &numbering_system_str); // 8. If _numberingSystem_ is not *undefined*, then // a. If _numberingSystem_ does not match the // `(3*8alphanum) *("-" (3*8alphanum))` sequence, throw a *RangeError* // exception. MAYBE_RETURN(maybe_numberingSystem, MaybeHandle<JSRelativeTimeFormat>()); // 9. Set _opt_.[[nu]] to _numberingSystem_. // 10. Let localeData be %RelativeTimeFormat%.[[LocaleData]]. // 11. Let r be // ResolveLocale(%RelativeTimeFormat%.[[AvailableLocales]], // requestedLocales, opt, // %RelativeTimeFormat%.[[RelevantExtensionKeys]], localeData). Maybe<Intl::ResolvedLocale> maybe_resolve_locale = Intl::ResolveLocale(isolate, JSRelativeTimeFormat::GetAvailableLocales(), requested_locales, matcher, {"nu"}); if (maybe_resolve_locale.IsNothing()) { THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError), JSRelativeTimeFormat); } Intl::ResolvedLocale r = maybe_resolve_locale.FromJust(); UErrorCode status = U_ZERO_ERROR; icu::Locale icu_locale = r.icu_locale; if (numbering_system_str != nullptr) { auto nu_extension_it = r.extensions.find("nu"); if (nu_extension_it != r.extensions.end() && nu_extension_it->second != numbering_system_str.get()) { icu_locale.setUnicodeKeywordValue("nu", nullptr, status); DCHECK(U_SUCCESS(status)); } } // 12. Let locale be r.[[Locale]]. Maybe<std::string> maybe_locale_str = Intl::ToLanguageTag(icu_locale); MAYBE_RETURN(maybe_locale_str, MaybeHandle<JSRelativeTimeFormat>()); // 13. Set relativeTimeFormat.[[Locale]] to locale. Handle<String> locale_str = isolate->factory()->NewStringFromAsciiChecked( maybe_locale_str.FromJust().c_str()); // 14. Set relativeTimeFormat.[[NumberingSystem]] to r.[[nu]]. if (numbering_system_str != nullptr && Intl::IsValidNumberingSystem(numbering_system_str.get())) { icu_locale.setUnicodeKeywordValue("nu", numbering_system_str.get(), status); DCHECK(U_SUCCESS(status)); } // 15. Let dataLocale be r.[[DataLocale]]. // 16. Let s be ? GetOption(options, "style", "string", // «"long", "short", "narrow"», "long"). Maybe<Style> maybe_style = GetStringOption<Style>( isolate, options, "style", service, {"long", "short", "narrow"}, {Style::LONG, Style::SHORT, Style::NARROW}, Style::LONG); MAYBE_RETURN(maybe_style, MaybeHandle<JSRelativeTimeFormat>()); Style style_enum = maybe_style.FromJust(); // 17. Set relativeTimeFormat.[[Style]] to s. // 18. Let numeric be ? GetOption(options, "numeric", "string", // «"always", "auto"», "always"). Maybe<Numeric> maybe_numeric = GetStringOption<Numeric>( isolate, options, "numeric", service, {"always", "auto"}, {Numeric::ALWAYS, Numeric::AUTO}, Numeric::ALWAYS); MAYBE_RETURN(maybe_numeric, MaybeHandle<JSRelativeTimeFormat>()); Numeric numeric_enum = maybe_numeric.FromJust(); // 19. Set relativeTimeFormat.[[Numeric]] to numeric. // 23. Let relativeTimeFormat.[[NumberFormat]] be // ? Construct(%NumberFormat%, « nfLocale, nfOptions »). icu::NumberFormat* number_format = icu::NumberFormat::createInstance(icu_locale, UNUM_DECIMAL, status); if (U_FAILURE(status)) { // Data build filter files excluded data in "rbnf_tree" since ECMA402 does // not support "algorithmic" numbering systems. Therefore we may get the // U_MISSING_RESOURCE_ERROR here. Fallback to locale without the numbering // system and create the object again. if (status == U_MISSING_RESOURCE_ERROR) { delete number_format; status = U_ZERO_ERROR; icu_locale.setUnicodeKeywordValue("nu", nullptr, status); DCHECK(U_SUCCESS(status)); number_format = icu::NumberFormat::createInstance(icu_locale, UNUM_DECIMAL, status); } if (U_FAILURE(status) || number_format == nullptr) { delete number_format; THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError), JSRelativeTimeFormat); } } if (number_format->getDynamicClassID() == icu::DecimalFormat::getStaticClassID()) { icu::DecimalFormat* decimal_format = static_cast<icu::DecimalFormat*>(number_format); decimal_format->setMinimumGroupingDigits(-2); } // Change UDISPCTX_CAPITALIZATION_NONE to other values if // ECMA402 later include option to change capitalization. // Ref: https://github.com/tc39/proposal-intl-relative-time/issues/11 icu::RelativeDateTimeFormatter* icu_formatter = new icu::RelativeDateTimeFormatter(icu_locale, number_format, toIcuStyle(style_enum), UDISPCTX_CAPITALIZATION_NONE, status); if (U_FAILURE(status) || icu_formatter == nullptr) { delete icu_formatter; THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError), JSRelativeTimeFormat); } Handle<String> numbering_system_string = isolate->factory()->NewStringFromAsciiChecked( Intl::GetNumberingSystem(icu_locale).c_str()); Handle<Managed<icu::RelativeDateTimeFormatter>> managed_formatter = Managed<icu::RelativeDateTimeFormatter>::FromRawPtr(isolate, 0, icu_formatter); Handle<JSRelativeTimeFormat> relative_time_format_holder = Handle<JSRelativeTimeFormat>::cast( isolate->factory()->NewFastOrSlowJSObjectFromMap(map)); DisallowGarbageCollection no_gc; relative_time_format_holder->set_flags(0); relative_time_format_holder->set_locale(*locale_str); relative_time_format_holder->set_numberingSystem(*numbering_system_string); relative_time_format_holder->set_numeric(numeric_enum); relative_time_format_holder->set_icu_formatter(*managed_formatter); // 25. Return relativeTimeFormat. return relative_time_format_holder; } namespace { Handle<String> StyleAsString(Isolate* isolate, Style style) { switch (style) { case Style::LONG: return ReadOnlyRoots(isolate).long_string_handle(); case Style::SHORT: return ReadOnlyRoots(isolate).short_string_handle(); case Style::NARROW: return ReadOnlyRoots(isolate).narrow_string_handle(); } UNREACHABLE(); } } // namespace Handle<JSObject> JSRelativeTimeFormat::ResolvedOptions( Isolate* isolate, Handle<JSRelativeTimeFormat> format_holder) { Factory* factory = isolate->factory(); icu::RelativeDateTimeFormatter* formatter = format_holder->icu_formatter().raw(); DCHECK_NOT_NULL(formatter); Handle<JSObject> result = factory->NewJSObject(isolate->object_function()); Handle<String> locale(format_holder->locale(), isolate); Handle<String> numberingSystem(format_holder->numberingSystem(), isolate); JSObject::AddProperty(isolate, result, factory->locale_string(), locale, NONE); JSObject::AddProperty( isolate, result, factory->style_string(), StyleAsString(isolate, fromIcuStyle(formatter->getFormatStyle())), NONE); JSObject::AddProperty(isolate, result, factory->numeric_string(), format_holder->NumericAsString(), NONE); JSObject::AddProperty(isolate, result, factory->numberingSystem_string(), numberingSystem, NONE); return result; } Handle<String> JSRelativeTimeFormat::NumericAsString() const { switch (numeric()) { case Numeric::ALWAYS: return GetReadOnlyRoots().always_string_handle(); case Numeric::AUTO: return GetReadOnlyRoots().auto_string_handle(); } UNREACHABLE(); } namespace { Handle<String> UnitAsString(Isolate* isolate, URelativeDateTimeUnit unit_enum) { Factory* factory = isolate->factory(); switch (unit_enum) { case UDAT_REL_UNIT_SECOND: return factory->second_string(); case UDAT_REL_UNIT_MINUTE: return factory->minute_string(); case UDAT_REL_UNIT_HOUR: return factory->hour_string(); case UDAT_REL_UNIT_DAY: return factory->day_string(); case UDAT_REL_UNIT_WEEK: return factory->week_string(); case UDAT_REL_UNIT_MONTH: return factory->month_string(); case UDAT_REL_UNIT_QUARTER: return factory->quarter_string(); case UDAT_REL_UNIT_YEAR: return factory->year_string(); default: UNREACHABLE(); } } bool GetURelativeDateTimeUnit(Handle<String> unit, URelativeDateTimeUnit* unit_enum) { std::unique_ptr<char[]> unit_str = unit->ToCString(); if ((strcmp("second", unit_str.get()) == 0) || (strcmp("seconds", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_SECOND; } else if ((strcmp("minute", unit_str.get()) == 0) || (strcmp("minutes", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_MINUTE; } else if ((strcmp("hour", unit_str.get()) == 0) || (strcmp("hours", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_HOUR; } else if ((strcmp("day", unit_str.get()) == 0) || (strcmp("days", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_DAY; } else if ((strcmp("week", unit_str.get()) == 0) || (strcmp("weeks", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_WEEK; } else if ((strcmp("month", unit_str.get()) == 0) || (strcmp("months", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_MONTH; } else if ((strcmp("quarter", unit_str.get()) == 0) || (strcmp("quarters", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_QUARTER; } else if ((strcmp("year", unit_str.get()) == 0) || (strcmp("years", unit_str.get()) == 0)) { *unit_enum = UDAT_REL_UNIT_YEAR; } else { return false; } return true; } template <typename T> MaybeHandle<T> FormatCommon( Isolate* isolate, Handle<JSRelativeTimeFormat> format, Handle<Object> value_obj, Handle<Object> unit_obj, const char* func_name, MaybeHandle<T> (*formatToResult)(Isolate*, const icu::FormattedRelativeDateTime&, Handle<String>, bool)) { // 3. Let value be ? ToNumber(value). Handle<Object> value; ASSIGN_RETURN_ON_EXCEPTION(isolate, value, Object::ToNumber(isolate, value_obj), T); double number = value->Number(); // 4. Let unit be ? ToString(unit). Handle<String> unit; ASSIGN_RETURN_ON_EXCEPTION(isolate, unit, Object::ToString(isolate, unit_obj), T); // 4. If isFinite(value) is false, then throw a RangeError exception. if (!std::isfinite(number)) { THROW_NEW_ERROR( isolate, NewRangeError(MessageTemplate::kNotFiniteNumber, isolate->factory()->NewStringFromAsciiChecked(func_name)), T); } icu::RelativeDateTimeFormatter* formatter = format->icu_formatter().raw(); DCHECK_NOT_NULL(formatter); URelativeDateTimeUnit unit_enum; if (!GetURelativeDateTimeUnit(unit, &unit_enum)) { THROW_NEW_ERROR( isolate, NewRangeError(MessageTemplate::kInvalidUnit, isolate->factory()->NewStringFromAsciiChecked(func_name), unit), T); } UErrorCode status = U_ZERO_ERROR; icu::FormattedRelativeDateTime formatted = (format->numeric() == JSRelativeTimeFormat::Numeric::ALWAYS) ? formatter->formatNumericToValue(number, unit_enum, status) : formatter->formatToValue(number, unit_enum, status); if (U_FAILURE(status)) { THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kIcuError), T); } return formatToResult(isolate, formatted, UnitAsString(isolate, unit_enum), value->IsNaN()); } MaybeHandle<String> FormatToString( Isolate* isolate, const icu::FormattedRelativeDateTime& formatted, Handle<String> unit, bool is_nan) { UErrorCode status = U_ZERO_ERROR; icu::UnicodeString result = formatted.toString(status); if (U_FAILURE(status)) { THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kIcuError), String); } return Intl::ToString(isolate, result); } Maybe<bool> AddLiteral(Isolate* isolate, Handle<JSArray> array, const icu::UnicodeString& string, int32_t index, int32_t start, int32_t limit) { Handle<String> substring; ASSIGN_RETURN_ON_EXCEPTION_VALUE( isolate, substring, Intl::ToString(isolate, string, start, limit), Nothing<bool>()); Intl::AddElement(isolate, array, index, isolate->factory()->literal_string(), substring); return Just(true); } Maybe<bool> AddUnit(Isolate* isolate, Handle<JSArray> array, const icu::UnicodeString& string, int32_t index, const NumberFormatSpan& part, Handle<String> unit, bool is_nan) { Handle<String> substring; ASSIGN_RETURN_ON_EXCEPTION_VALUE( isolate, substring, Intl::ToString(isolate, string, part.begin_pos, part.end_pos), Nothing<bool>()); Intl::AddElement(isolate, array, index, Intl::NumberFieldToType(isolate, part, string, is_nan), substring, isolate->factory()->unit_string(), unit); return Just(true); } MaybeHandle<JSArray> FormatToJSArray( Isolate* isolate, const icu::FormattedRelativeDateTime& formatted, Handle<String> unit, bool is_nan) { UErrorCode status = U_ZERO_ERROR; icu::UnicodeString string = formatted.toString(status); Factory* factory = isolate->factory(); Handle<JSArray> array = factory->NewJSArray(0); icu::ConstrainedFieldPosition cfpos; cfpos.constrainCategory(UFIELD_CATEGORY_NUMBER); int32_t index = 0; int32_t previous_end = 0; Handle<String> substring; std::vector<std::pair<int32_t, int32_t>> groups; while (formatted.nextPosition(cfpos, status) && U_SUCCESS(status)) { int32_t category = cfpos.getCategory(); int32_t field = cfpos.getField(); int32_t start = cfpos.getStart(); int32_t limit = cfpos.getLimit(); if (category == UFIELD_CATEGORY_NUMBER) { if (field == UNUM_GROUPING_SEPARATOR_FIELD) { groups.push_back(std::pair<int32_t, int32_t>(start, limit)); continue; } if (start > previous_end) { Maybe<bool> maybe_added = AddLiteral(isolate, array, string, index++, previous_end, start); MAYBE_RETURN(maybe_added, Handle<JSArray>()); } if (field == UNUM_INTEGER_FIELD) { for (auto start_limit : groups) { if (start_limit.first > start) { Maybe<bool> maybe_added = AddUnit(isolate, array, string, index++, NumberFormatSpan(field, start, start_limit.first), unit, is_nan); MAYBE_RETURN(maybe_added, Handle<JSArray>()); maybe_added = AddUnit(isolate, array, string, index++, NumberFormatSpan(UNUM_GROUPING_SEPARATOR_FIELD, start_limit.first, start_limit.second), unit, is_nan); MAYBE_RETURN(maybe_added, Handle<JSArray>()); start = start_limit.second; } } } Maybe<bool> maybe_added = AddUnit(isolate, array, string, index++, NumberFormatSpan(field, start, limit), unit, is_nan); MAYBE_RETURN(maybe_added, Handle<JSArray>()); previous_end = limit; } } if (U_FAILURE(status)) { THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kIcuError), JSArray); } if (string.length() > previous_end) { Maybe<bool> maybe_added = AddLiteral(isolate, array, string, index, previous_end, string.length()); MAYBE_RETURN(maybe_added, Handle<JSArray>()); } JSObject::ValidateElements(*array); return array; } } // namespace MaybeHandle<String> JSRelativeTimeFormat::Format( Isolate* isolate, Handle<Object> value_obj, Handle<Object> unit_obj, Handle<JSRelativeTimeFormat> format) { return FormatCommon<String>(isolate, format, value_obj, unit_obj, "Intl.RelativeTimeFormat.prototype.format", FormatToString); } MaybeHandle<JSArray> JSRelativeTimeFormat::FormatToParts( Isolate* isolate, Handle<Object> value_obj, Handle<Object> unit_obj, Handle<JSRelativeTimeFormat> format) { return FormatCommon<JSArray>( isolate, format, value_obj, unit_obj, "Intl.RelativeTimeFormat.prototype.formatToParts", FormatToJSArray); } const std::set<std::string>& JSRelativeTimeFormat::GetAvailableLocales() { // Since RelativeTimeFormatter does not have a method to list all // available locales, work around by calling the DateFormat. return Intl::GetAvailableLocalesForDateFormat(); } } // namespace internal } // namespace v8