| // Copyright 2022 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-duration-format.h" |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <string_view> |
| |
| #include "src/execution/isolate.h" |
| #include "src/heap/factory.h" |
| #include "src/objects/intl-objects.h" |
| #include "src/objects/js-duration-format-inl.h" |
| #include "src/objects/js-number-format.h" |
| #include "src/objects/js-temporal-objects.h" |
| #include "src/objects/managed-inl.h" |
| #include "src/objects/objects-inl.h" |
| #include "src/objects/option-utils.h" |
| #include "unicode/dtfmtsym.h" |
| #include "unicode/listformatter.h" |
| #include "unicode/locid.h" |
| #include "unicode/numberformatter.h" |
| #include "unicode/ulistformatter.h" |
| #include "unicode/unumberformatter.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| using temporal::DurationRecord; |
| |
| namespace { |
| |
| // #sec-getdurationunitoptions |
| enum class StylesList { k3Styles, k4Styles, k5Styles }; |
| enum class UnitKind { kMinutesOrSeconds, kOthers }; |
| struct DurationUnitOptions { |
| JSDurationFormat::FieldStyle style; |
| JSDurationFormat::Display display; |
| }; |
| Maybe<DurationUnitOptions> GetDurationUnitOptions( |
| Isolate* isolate, const char* unit, const char* display_field, |
| Handle<JSReceiver> options, JSDurationFormat::Style base_style, |
| StylesList styles_list, JSDurationFormat::FieldStyle prev_style, |
| UnitKind unit_kind, const char* method_name) { |
| JSDurationFormat::FieldStyle style; |
| JSDurationFormat::FieldStyle digital_base; |
| // 1. Let style be ? GetOption(options, unit, "string", stylesList, |
| // undefined). |
| switch (styles_list) { |
| case StylesList::k3Styles: |
| // For years, months, weeks, days |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, style, |
| GetStringOption<JSDurationFormat::FieldStyle>( |
| isolate, options, unit, method_name, {"long", "short", "narrow"}, |
| {JSDurationFormat::FieldStyle::kLong, |
| JSDurationFormat::FieldStyle::kShort, |
| JSDurationFormat::FieldStyle::kNarrow}, |
| JSDurationFormat::FieldStyle::kUndefined), |
| Nothing<DurationUnitOptions>()); |
| digital_base = JSDurationFormat::FieldStyle::kShort; |
| break; |
| case StylesList::k4Styles: |
| // For milliseconds, microseconds, nanoseconds |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, style, |
| GetStringOption<JSDurationFormat::FieldStyle>( |
| isolate, options, unit, method_name, |
| {"long", "short", "narrow", "numeric"}, |
| {JSDurationFormat::FieldStyle::kLong, |
| JSDurationFormat::FieldStyle::kShort, |
| JSDurationFormat::FieldStyle::kNarrow, |
| JSDurationFormat::FieldStyle::kNumeric}, |
| JSDurationFormat::FieldStyle::kUndefined), |
| Nothing<DurationUnitOptions>()); |
| digital_base = JSDurationFormat::FieldStyle::kNumeric; |
| break; |
| case StylesList::k5Styles: |
| // For hours, minutes, seconds |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, style, |
| GetStringOption<JSDurationFormat::FieldStyle>( |
| isolate, options, unit, method_name, |
| {"long", "short", "narrow", "numeric", "2-digit"}, |
| {JSDurationFormat::FieldStyle::kLong, |
| JSDurationFormat::FieldStyle::kShort, |
| JSDurationFormat::FieldStyle::kNarrow, |
| JSDurationFormat::FieldStyle::kNumeric, |
| JSDurationFormat::FieldStyle::k2Digit}, |
| JSDurationFormat::FieldStyle::kUndefined), |
| Nothing<DurationUnitOptions>()); |
| digital_base = JSDurationFormat::FieldStyle::kNumeric; |
| break; |
| } |
| |
| // 2. Let displayDefault be "always". |
| JSDurationFormat::Display display_default = |
| JSDurationFormat::Display::kAlways; |
| // 3. If style is undefined, then |
| if (style == JSDurationFormat::FieldStyle::kUndefined) { |
| // a. If baseStyle is "digital", then |
| if (base_style == JSDurationFormat::Style::kDigital) { |
| // i. If unit is not one of "hours", "minutes", or "seconds", then |
| if (styles_list != StylesList::k5Styles) { |
| DCHECK_NE(0, strcmp(unit, "hours")); |
| DCHECK_NE(0, strcmp(unit, "minutes")); |
| DCHECK_NE(0, strcmp(unit, "seconds")); |
| // a. Set displayDefault to "auto". |
| display_default = JSDurationFormat::Display::kAuto; |
| } |
| // ii. Set style to digitalBase. |
| style = digital_base; |
| // b. Else |
| } else { |
| // i. Set displayDefault to "auto". |
| display_default = JSDurationFormat::Display::kAuto; |
| // ii. if prevStyle is "numeric" or "2-digit", then |
| if (prev_style == JSDurationFormat::FieldStyle::kNumeric || |
| prev_style == JSDurationFormat::FieldStyle::k2Digit) { |
| // 1. Set style to "numeric". |
| style = JSDurationFormat::FieldStyle::kNumeric; |
| // iii. Else, |
| } else { |
| // 1. Set style to baseStyle. |
| switch (base_style) { |
| case JSDurationFormat::Style::kLong: |
| style = JSDurationFormat::FieldStyle::kLong; |
| break; |
| case JSDurationFormat::Style::kShort: |
| style = JSDurationFormat::FieldStyle::kShort; |
| break; |
| case JSDurationFormat::Style::kNarrow: |
| style = JSDurationFormat::FieldStyle::kNarrow; |
| break; |
| default: |
| UNREACHABLE(); |
| } |
| } |
| } |
| } |
| // 4. Let displayField be the string-concatenation of unit and "Display". |
| // 5. Let display be ? GetOption(options, displayField, "string", « "auto", |
| // "always" », displayDefault). |
| JSDurationFormat::Display display; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, display, |
| GetStringOption<JSDurationFormat::Display>( |
| isolate, options, display_field, method_name, {"auto", "always"}, |
| {JSDurationFormat::Display::kAuto, |
| JSDurationFormat::Display::kAlways}, |
| display_default), |
| Nothing<DurationUnitOptions>()); |
| // 6. If prevStyle is "numeric" or "2-digit", then |
| if (prev_style == JSDurationFormat::FieldStyle::kNumeric || |
| prev_style == JSDurationFormat::FieldStyle::k2Digit) { |
| // a. If style is not "numeric" or "2-digit", then |
| if (style != JSDurationFormat::FieldStyle::kNumeric && |
| style != JSDurationFormat::FieldStyle::k2Digit) { |
| // i. Throw a RangeError exception. |
| // b. Else if unit is "minutes" or "seconds", then |
| } else if (unit_kind == UnitKind::kMinutesOrSeconds) { |
| CHECK(strcmp(unit, "minutes") == 0 || strcmp(unit, "seconds") == 0); |
| // i. Set style to "2-digit". |
| style = JSDurationFormat::FieldStyle::k2Digit; |
| } |
| } |
| // 7. Return the Record { [[Style]]: style, [[Display]]: display }. |
| return Just(DurationUnitOptions({style, display})); |
| } |
| |
| JSDurationFormat::Separator GetSeparator(const icu::Locale& l) { |
| UErrorCode status = U_ZERO_ERROR; |
| icu::DateFormatSymbols sym(l, status); |
| if (U_FAILURE(status)) return JSDurationFormat::Separator::kColon; |
| icu::UnicodeString sep; |
| sym.getTimeSeparatorString(sep); |
| if (sep.length() != 1) return JSDurationFormat::Separator::kColon; |
| switch (sep.charAt(0)) { |
| case u'.': |
| return JSDurationFormat::Separator::kFullStop; |
| case u'\uFF1A': |
| return JSDurationFormat::Separator::kFullwidthColon; |
| case u'\u066B': |
| return JSDurationFormat::Separator::kArabicDecimalSeparator; |
| // By default, or if we get anything else, just use ':'. |
| default: |
| return JSDurationFormat::Separator::kColon; |
| } |
| } |
| |
| } // namespace |
| MaybeHandle<JSDurationFormat> JSDurationFormat::New( |
| Isolate* isolate, Handle<Map> map, Handle<Object> locales, |
| Handle<Object> input_options) { |
| Factory* factory = isolate->factory(); |
| const char* method_name = "Intl.DurationFormat"; |
| |
| // 3. Let requestedLocales be ? CanonicalizeLocaleList(locales). |
| std::vector<std::string> requested_locales; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, requested_locales, |
| Intl::CanonicalizeLocaleList(isolate, locales), |
| Handle<JSDurationFormat>()); |
| |
| // 4. Let options be ? GetOptionsObject(options). |
| Handle<JSReceiver> options; |
| ASSIGN_RETURN_ON_EXCEPTION( |
| isolate, options, GetOptionsObject(isolate, input_options, method_name), |
| JSDurationFormat); |
| |
| // 5. Let matcher be ? GetOption(options, "localeMatcher", "string", « |
| // "lookup", "best fit" », "best fit"). |
| Intl::MatcherOption matcher; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, matcher, Intl::GetLocaleMatcher(isolate, options, method_name), |
| Handle<JSDurationFormat>()); |
| |
| // 6. Let numberingSystem be ? GetOption(options, "numberingSystem", "string", |
| // undefined, undefined). |
| // |
| // 7. If numberingSystem is not undefined, then |
| // |
| // a. If numberingSystem does not match the Unicode Locale Identifier type |
| // nonterminal, throw a RangeError exception. |
| // Note: The matching test and throw in Step 7-a is throw inside |
| // Intl::GetNumberingSystem. |
| std::unique_ptr<char[]> numbering_system_str = nullptr; |
| bool get; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, get, |
| Intl::GetNumberingSystem(isolate, options, method_name, |
| &numbering_system_str), |
| Handle<JSDurationFormat>()); |
| |
| // 8. Let opt be the Record { [[localeMatcher]]: matcher, [[nu]]: |
| // numberingSystem }. |
| // 9. Let r be ResolveLocale(%DurationFormat%.[[AvailableLocales]], |
| // requestedLocales, opt, %DurationFormat%.[[RelevantExtensionKeys]], |
| // %DurationFormat%.[[LocaleData]]). |
| std::set<std::string> relevant_extension_keys{"nu"}; |
| Intl::ResolvedLocale r; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, r, |
| Intl::ResolveLocale(isolate, JSDurationFormat::GetAvailableLocales(), |
| requested_locales, matcher, relevant_extension_keys), |
| Handle<JSDurationFormat>()); |
| |
| // 10. Let locale be r.[[locale]]. |
| icu::Locale r_locale = r.icu_locale; |
| UErrorCode status = U_ZERO_ERROR; |
| // 11. Set durationFormat.[[Locale]] to locale. |
| // 12. Set durationFormat.[[NumberingSystem]] to r.[[nu]]. |
| 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()) { |
| r_locale.setUnicodeKeywordValue("nu", nullptr, status); |
| DCHECK(U_SUCCESS(status)); |
| } |
| } |
| icu::Locale icu_locale = r_locale; |
| if (numbering_system_str != nullptr && |
| Intl::IsValidNumberingSystem(numbering_system_str.get())) { |
| r_locale.setUnicodeKeywordValue("nu", numbering_system_str.get(), status); |
| DCHECK(U_SUCCESS(status)); |
| } |
| std::string numbering_system = Intl::GetNumberingSystem(r_locale); |
| Separator separator = GetSeparator(r_locale); |
| |
| // 13. Let style be ? GetOption(options, "style", "string", « "long", "short", |
| // "narrow", "digital" », "long"). |
| Style style; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, style, |
| GetStringOption<Style>( |
| isolate, options, "style", method_name, |
| {"long", "short", "narrow", "digital"}, |
| {Style::kLong, Style::kShort, Style::kNarrow, Style::kDigital}, |
| Style::kShort), |
| Handle<JSDurationFormat>()); |
| |
| // 14. Set durationFormat.[[Style]] to style. |
| // 15. Set durationFormat.[[DataLocale]] to r.[[dataLocale]]. |
| Handle<Managed<icu::Locale>> managed_locale = |
| Managed<icu::Locale>::FromRawPtr(isolate, 0, icu_locale.clone()); |
| // 16. Let prevStyle be the empty String. |
| FieldStyle prev_style = FieldStyle::kUndefined; |
| // 17. For each row of Table 1, except the header row, in table order, do |
| // a. Let styleSlot be the Style Slot value of the current row. |
| // b. Let displaySlot be the Display Slot value of the current row. |
| // c. Let unit be the Unit value. |
| // d. Let valueList be the Values value. |
| // e. Let digitalBase be the Digital Default value. |
| // f. Let unitOptions be ? GetDurationUnitOptions(unit, options, style, |
| // valueList, digitalBase, prevStyle). |
| // of durationFormat to unitOptions.[[Style]]. |
| // h. Set the value of the |
| // displaySlot slot of durationFormat to unitOptions.[[Display]]. |
| // i. If unit is one of "hours", "minutes", "seconds", "milliseconds", |
| // or "microseconds", then |
| // i. Set prevStyle to unitOptions.[[Style]]. |
| // g. Set the value of the styleSlot slot |
| DurationUnitOptions years_option; |
| DurationUnitOptions months_option; |
| DurationUnitOptions weeks_option; |
| DurationUnitOptions days_option; |
| DurationUnitOptions hours_option; |
| DurationUnitOptions minutes_option; |
| DurationUnitOptions seconds_option; |
| DurationUnitOptions milliseconds_option; |
| DurationUnitOptions microseconds_option; |
| DurationUnitOptions nanoseconds_option; |
| |
| #define CALL_GET_DURATION_UNIT_OPTIONS(u, sl, uk) \ |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( \ |
| isolate, u##_option, \ |
| GetDurationUnitOptions(isolate, #u, #u "Display", options, style, sl, \ |
| prev_style, uk, method_name), \ |
| Handle<JSDurationFormat>()); |
| CALL_GET_DURATION_UNIT_OPTIONS(years, StylesList::k3Styles, UnitKind::kOthers) |
| CALL_GET_DURATION_UNIT_OPTIONS(months, StylesList::k3Styles, |
| UnitKind::kOthers) |
| CALL_GET_DURATION_UNIT_OPTIONS(weeks, StylesList::k3Styles, UnitKind::kOthers) |
| CALL_GET_DURATION_UNIT_OPTIONS(days, StylesList::k3Styles, UnitKind::kOthers) |
| CALL_GET_DURATION_UNIT_OPTIONS(hours, StylesList::k5Styles, UnitKind::kOthers) |
| prev_style = hours_option.style; |
| CALL_GET_DURATION_UNIT_OPTIONS(minutes, StylesList::k5Styles, |
| UnitKind::kMinutesOrSeconds) |
| prev_style = minutes_option.style; |
| CALL_GET_DURATION_UNIT_OPTIONS(seconds, StylesList::k5Styles, |
| UnitKind::kMinutesOrSeconds) |
| prev_style = seconds_option.style; |
| CALL_GET_DURATION_UNIT_OPTIONS(milliseconds, StylesList::k4Styles, |
| UnitKind::kOthers) |
| prev_style = milliseconds_option.style; |
| CALL_GET_DURATION_UNIT_OPTIONS(microseconds, StylesList::k4Styles, |
| UnitKind::kOthers) |
| prev_style = microseconds_option.style; |
| CALL_GET_DURATION_UNIT_OPTIONS(nanoseconds, StylesList::k4Styles, |
| UnitKind::kOthers) |
| #undef CALL_GET_DURATION_UNIT_OPTIONS |
| // 18. Set durationFormat.[[FractionalDigits]] to ? GetNumberOption(options, |
| // "fractionalDigits", 0, 9, undefined). |
| int fractional_digits; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, fractional_digits, |
| GetNumberOption(isolate, options, factory->fractionalDigits_string(), 0, |
| 9, kUndefinedFractionalDigits), |
| Handle<JSDurationFormat>()); |
| |
| icu::number::LocalizedNumberFormatter fmt = |
| icu::number::UnlocalizedNumberFormatter() |
| .roundingMode(UNUM_ROUND_HALFUP) |
| .locale(icu_locale); |
| if (!numbering_system.empty() && numbering_system != "latn") { |
| fmt = fmt.adoptSymbols(icu::NumberingSystem::createInstanceByName( |
| numbering_system.c_str(), status)); |
| DCHECK(U_SUCCESS(status)); |
| } |
| Handle<Managed<icu::number::LocalizedNumberFormatter>> |
| managed_number_formatter = |
| Managed<icu::number::LocalizedNumberFormatter>::FromRawPtr( |
| isolate, 0, new icu::number::LocalizedNumberFormatter(fmt)); |
| |
| // 19. Return durationFormat. |
| Handle<JSDurationFormat> duration_format = Handle<JSDurationFormat>::cast( |
| factory->NewFastOrSlowJSObjectFromMap(map)); |
| duration_format->set_style_flags(0); |
| duration_format->set_display_flags(0); |
| duration_format->set_style(style); |
| duration_format->set_years_style(years_option.style); |
| duration_format->set_months_style(months_option.style); |
| duration_format->set_weeks_style(weeks_option.style); |
| duration_format->set_days_style(days_option.style); |
| duration_format->set_hours_style(hours_option.style); |
| duration_format->set_minutes_style(minutes_option.style); |
| duration_format->set_seconds_style(seconds_option.style); |
| duration_format->set_milliseconds_style(milliseconds_option.style); |
| duration_format->set_microseconds_style(microseconds_option.style); |
| duration_format->set_nanoseconds_style(nanoseconds_option.style); |
| duration_format->set_separator(separator); |
| |
| duration_format->set_years_display(years_option.display); |
| duration_format->set_months_display(months_option.display); |
| duration_format->set_weeks_display(weeks_option.display); |
| duration_format->set_days_display(days_option.display); |
| duration_format->set_hours_display(hours_option.display); |
| duration_format->set_minutes_display(minutes_option.display); |
| duration_format->set_seconds_display(seconds_option.display); |
| duration_format->set_milliseconds_display(milliseconds_option.display); |
| duration_format->set_microseconds_display(microseconds_option.display); |
| duration_format->set_nanoseconds_display(nanoseconds_option.display); |
| |
| duration_format->set_fractional_digits(fractional_digits); |
| |
| duration_format->set_icu_locale(*managed_locale); |
| duration_format->set_icu_number_formatter(*managed_number_formatter); |
| |
| return duration_format; |
| } |
| |
| namespace { |
| |
| Handle<String> StyleToString(Isolate* isolate, JSDurationFormat::Style style) { |
| switch (style) { |
| case JSDurationFormat::Style::kLong: |
| return ReadOnlyRoots(isolate).long_string_handle(); |
| case JSDurationFormat::Style::kShort: |
| return ReadOnlyRoots(isolate).short_string_handle(); |
| case JSDurationFormat::Style::kNarrow: |
| return ReadOnlyRoots(isolate).narrow_string_handle(); |
| case JSDurationFormat::Style::kDigital: |
| return ReadOnlyRoots(isolate).digital_string_handle(); |
| } |
| } |
| |
| Handle<String> StyleToString(Isolate* isolate, |
| JSDurationFormat::FieldStyle style) { |
| switch (style) { |
| case JSDurationFormat::FieldStyle::kLong: |
| return ReadOnlyRoots(isolate).long_string_handle(); |
| case JSDurationFormat::FieldStyle::kShort: |
| return ReadOnlyRoots(isolate).short_string_handle(); |
| case JSDurationFormat::FieldStyle::kNarrow: |
| return ReadOnlyRoots(isolate).narrow_string_handle(); |
| case JSDurationFormat::FieldStyle::kNumeric: |
| return ReadOnlyRoots(isolate).numeric_string_handle(); |
| case JSDurationFormat::FieldStyle::k2Digit: |
| return ReadOnlyRoots(isolate).two_digit_string_handle(); |
| case JSDurationFormat::FieldStyle::kUndefined: |
| UNREACHABLE(); |
| } |
| } |
| |
| Handle<String> DisplayToString(Isolate* isolate, |
| JSDurationFormat::Display display) { |
| switch (display) { |
| case JSDurationFormat::Display::kAuto: |
| return ReadOnlyRoots(isolate).auto_string_handle(); |
| case JSDurationFormat::Display::kAlways: |
| return ReadOnlyRoots(isolate).always_string_handle(); |
| } |
| } |
| |
| } // namespace |
| |
| Handle<JSObject> JSDurationFormat::ResolvedOptions( |
| Isolate* isolate, Handle<JSDurationFormat> format) { |
| Factory* factory = isolate->factory(); |
| Handle<JSObject> options = factory->NewJSObject(isolate->object_function()); |
| |
| Handle<String> locale = factory->NewStringFromAsciiChecked( |
| Intl::ToLanguageTag(*format->icu_locale()->raw()).FromJust().c_str()); |
| UErrorCode status = U_ZERO_ERROR; |
| icu::UnicodeString skeleton = |
| format->icu_number_formatter()->raw()->toSkeleton(status); |
| DCHECK(U_SUCCESS(status)); |
| |
| Handle<String> numbering_system; |
| CHECK(Intl::ToString(isolate, |
| JSNumberFormat::NumberingSystemFromSkeleton(skeleton)) |
| .ToHandle(&numbering_system)); |
| |
| bool created; |
| |
| #define OUTPUT_PROPERTY(s, f) \ |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( \ |
| isolate, created, \ |
| JSReceiver::CreateDataProperty(isolate, options, factory->s(), f, \ |
| Just(kDontThrow)), \ |
| Handle<JSObject>()); \ |
| CHECK(created); |
| #define OUTPUT_STYLE_PROPERTY(p) \ |
| OUTPUT_PROPERTY(p##_string, StyleToString(isolate, format->p##_style())) |
| #define OUTPUT_DISPLAY_PROPERTY(p) \ |
| OUTPUT_PROPERTY(p##Display_string, \ |
| DisplayToString(isolate, format->p##_display())) |
| #define OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(p) \ |
| OUTPUT_STYLE_PROPERTY(p); \ |
| OUTPUT_DISPLAY_PROPERTY(p); |
| |
| OUTPUT_PROPERTY(locale_string, locale); |
| OUTPUT_PROPERTY(style_string, StyleToString(isolate, format->style())); |
| |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(years); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(months); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(weeks); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(days); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(hours); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(minutes); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(seconds); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(milliseconds); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(microseconds); |
| OUTPUT_STYLE_AND_DISPLAY_PROPERTIES(nanoseconds); |
| |
| int32_t fractional_digits = format->fractional_digits(); |
| if (kUndefinedFractionalDigits == fractional_digits) { |
| OUTPUT_PROPERTY(fractionalDigits_string, factory->undefined_value()); |
| } else { |
| Handle<Smi> fractional_digits_obj = |
| handle(Smi::FromInt(fractional_digits), isolate); |
| OUTPUT_PROPERTY(fractionalDigits_string, fractional_digits_obj); |
| } |
| OUTPUT_PROPERTY(numberingSystem_string, numbering_system); |
| #undef OUTPUT_PROPERTY |
| #undef OUTPUT_STYLE_PROPERTY |
| #undef OUTPUT_DISPLAY_PROPERTY |
| #undef OUTPUT_STYLE_AND_DISPLAY_PROPERTIES |
| |
| return options; |
| } |
| |
| namespace { |
| |
| UNumberUnitWidth ToUNumberUnitWidth(JSDurationFormat::FieldStyle style) { |
| switch (style) { |
| case JSDurationFormat::FieldStyle::kShort: |
| return UNumberUnitWidth::UNUM_UNIT_WIDTH_SHORT; |
| case JSDurationFormat::FieldStyle::kLong: |
| return UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME; |
| case JSDurationFormat::FieldStyle::kNarrow: |
| return UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW; |
| default: |
| UNREACHABLE(); |
| } |
| } |
| |
| struct Part { |
| enum Type { kFormatted, kSeparator }; |
| Type part_type; |
| std::string type; |
| icu::number::FormattedNumber formatted; |
| }; |
| |
| char16_t SeparatorToChar(JSDurationFormat::Separator separator) { |
| switch (separator) { |
| case JSDurationFormat::Separator::kColon: |
| return u':'; |
| case JSDurationFormat::Separator::kFullStop: |
| return u'.'; |
| case JSDurationFormat::Separator::kFullwidthColon: |
| return u'\uFF1A'; |
| case JSDurationFormat::Separator::kArabicDecimalSeparator: |
| return u'\u066B'; |
| } |
| } |
| |
| void Output(const char* type, double value, |
| const icu::number::LocalizedNumberFormatter& fmt, bool addToLast, |
| JSDurationFormat::Separator separator, |
| std::vector<std::vector<Part>>* parts, |
| std::vector<icu::UnicodeString>* strings) { |
| UErrorCode status = U_ZERO_ERROR; |
| icu::number::FormattedNumber formatted = fmt.formatDouble(value, status); |
| icu::UnicodeString unit_string = formatted.toString(status); |
| CHECK(U_SUCCESS(status)); |
| Part p = {Part::Type::kFormatted, std::string(type), std::move(formatted)}; |
| if (addToLast && !strings->empty()) { |
| strings->back().append(SeparatorToChar(separator)); |
| strings->back() += unit_string; |
| |
| if (parts != nullptr) { |
| icu::number::FormattedNumber dummy; |
| Part s = {Part::Type::kSeparator, std::string(), std::move(dummy)}; |
| parts->back().push_back(std::move(s)); |
| parts->back().push_back(std::move(p)); |
| } |
| return; |
| } |
| strings->push_back(unit_string); |
| if (parts != nullptr) { |
| std::vector<Part> v; |
| v.push_back(std::move(p)); |
| parts->push_back(std::move(v)); |
| } |
| } |
| |
| void Output3Styles(const char* type, double value, |
| JSDurationFormat::Display display, |
| const icu::number::LocalizedNumberFormatter& fmt, |
| bool addToLast, JSDurationFormat::Separator separator, |
| std::vector<std::vector<Part>>* parts, |
| std::vector<icu::UnicodeString>* strings) { |
| if (value == 0 && display == JSDurationFormat::Display::kAuto) return; |
| Output(type, value, fmt, addToLast, separator, parts, strings); |
| } |
| |
| void Output4Styles(const char* type, double value, |
| JSDurationFormat::Display display, |
| JSDurationFormat::FieldStyle style, |
| const icu::number::LocalizedNumberFormatter& fmt, |
| icu::MeasureUnit unit, bool addToLast, |
| JSDurationFormat::Separator separator, |
| std::vector<std::vector<Part>>* parts, |
| std::vector<icu::UnicodeString>* strings) { |
| if (value == 0 && display == JSDurationFormat::Display::kAuto) return; |
| if (style == JSDurationFormat::FieldStyle::kNumeric) { |
| return Output(type, value, fmt, addToLast, separator, parts, strings); |
| } |
| Output3Styles(type, value, display, |
| fmt.unit(unit).unitWidth(ToUNumberUnitWidth(style)), addToLast, |
| separator, parts, strings); |
| } |
| void Output5Styles(const char* type, double value, |
| JSDurationFormat::Display display, |
| JSDurationFormat::FieldStyle style, |
| const icu::number::LocalizedNumberFormatter& fmt, |
| icu::MeasureUnit unit, bool maybeAddToLast, |
| JSDurationFormat::Separator separator, |
| std::vector<std::vector<Part>>* parts, |
| std::vector<icu::UnicodeString>* strings) { |
| if (value == 0 && display == JSDurationFormat::Display::kAuto) return; |
| if (style == JSDurationFormat::FieldStyle::k2Digit) { |
| return Output(type, value, |
| fmt.integerWidth(icu::number::IntegerWidth::zeroFillTo(2)), |
| maybeAddToLast, separator, parts, strings); |
| } |
| Output4Styles( |
| type, value, display, style, fmt, unit, |
| (maybeAddToLast && JSDurationFormat::FieldStyle::kNumeric == style), |
| separator, parts, strings); |
| } |
| |
| void DurationRecordToListOfFormattedNumber( |
| Handle<JSDurationFormat> df, |
| const icu::number::LocalizedNumberFormatter& fmt, |
| const DurationRecord& record, std::vector<std::vector<Part>>* parts, |
| std::vector<icu::UnicodeString>* strings) { |
| JSDurationFormat::Separator separator = df->separator(); |
| Output3Styles("year", record.years, df->years_display(), |
| fmt.unit(icu::MeasureUnit::getYear()) |
| .unitWidth(ToUNumberUnitWidth(df->years_style())), |
| false, separator, parts, strings); |
| Output3Styles("month", record.months, df->months_display(), |
| fmt.unit(icu::MeasureUnit::getMonth()) |
| .unitWidth(ToUNumberUnitWidth(df->months_style())), |
| false, separator, parts, strings); |
| Output3Styles("week", record.weeks, df->weeks_display(), |
| fmt.unit(icu::MeasureUnit::getWeek()) |
| .unitWidth(ToUNumberUnitWidth(df->weeks_style())), |
| false, separator, parts, strings); |
| Output3Styles("day", record.time_duration.days, df->days_display(), |
| fmt.unit(icu::MeasureUnit::getDay()) |
| .unitWidth(ToUNumberUnitWidth(df->days_style())), |
| false, separator, parts, strings); |
| Output5Styles("hour", record.time_duration.hours, df->hours_display(), |
| df->hours_style(), fmt, icu::MeasureUnit::getHour(), false, |
| separator, parts, strings); |
| Output5Styles("minute", record.time_duration.minutes, df->minutes_display(), |
| df->minutes_style(), fmt, icu::MeasureUnit::getMinute(), true, |
| separator, parts, strings); |
| int32_t fractional_digits = df->fractional_digits(); |
| int32_t maximumFractionDigits = |
| (fractional_digits == JSDurationFormat::kUndefinedFractionalDigits) |
| ? 9 |
| : fractional_digits; |
| int32_t minimumFractionDigits = |
| (fractional_digits == JSDurationFormat::kUndefinedFractionalDigits) |
| ? 0 |
| : fractional_digits; |
| |
| if (df->milliseconds_style() == JSDurationFormat::FieldStyle::kNumeric) { |
| // a. Set value to value + duration.[[Milliseconds]] / 10^3 + |
| // duration.[[Microseconds]] / 10^6 + duration.[[Nanoseconds]] / 10^9. |
| double value = record.time_duration.seconds + |
| record.time_duration.milliseconds / 1e3 + |
| record.time_duration.microseconds / 1e6 + |
| record.time_duration.nanoseconds / 1e9; |
| Output5Styles("second", value, df->seconds_display(), df->seconds_style(), |
| fmt.precision(icu::number::Precision::minMaxFraction( |
| minimumFractionDigits, maximumFractionDigits)), |
| icu::MeasureUnit::getSecond(), true, separator, parts, |
| strings); |
| return; |
| } |
| Output5Styles("second", record.time_duration.seconds, df->seconds_display(), |
| df->seconds_style(), fmt, icu::MeasureUnit::getSecond(), true, |
| separator, parts, strings); |
| |
| if (df->microseconds_style() == JSDurationFormat::FieldStyle::kNumeric) { |
| // a. Set value to value + duration.[[Microseconds]] / 10^3 + |
| // duration.[[Nanoseconds]] / 10^6. |
| double value = record.time_duration.milliseconds + |
| record.time_duration.microseconds / 1e3 + |
| record.time_duration.nanoseconds / 1e6; |
| Output4Styles("millisecond", value, df->milliseconds_display(), |
| df->milliseconds_style(), |
| fmt.precision(icu::number::Precision::minMaxFraction( |
| minimumFractionDigits, maximumFractionDigits)), |
| icu::MeasureUnit::getMillisecond(), false, separator, parts, |
| strings); |
| return; |
| } |
| Output4Styles("millisecond", record.time_duration.milliseconds, |
| df->milliseconds_display(), df->milliseconds_style(), fmt, |
| icu::MeasureUnit::getMillisecond(), false, separator, parts, |
| strings); |
| |
| if (df->nanoseconds_style() == JSDurationFormat::FieldStyle::kNumeric) { |
| // a. Set value to value + duration.[[Nanoseconds]] / 10^3. |
| double value = record.time_duration.microseconds + |
| record.time_duration.nanoseconds / 1e3; |
| Output4Styles("microsecond", value, df->microseconds_display(), |
| df->microseconds_style(), |
| fmt.precision(icu::number::Precision::minMaxFraction( |
| minimumFractionDigits, maximumFractionDigits)), |
| icu::MeasureUnit::getMicrosecond(), false, separator, parts, |
| strings); |
| return; |
| } |
| Output4Styles("microsecond", record.time_duration.microseconds, |
| df->microseconds_display(), df->microseconds_style(), fmt, |
| icu::MeasureUnit::getMicrosecond(), false, separator, parts, |
| strings); |
| |
| Output4Styles("nanosecond", record.time_duration.nanoseconds, |
| df->nanoseconds_display(), df->nanoseconds_style(), fmt, |
| icu::MeasureUnit::getNanosecond(), false, separator, parts, |
| strings); |
| } |
| |
| UListFormatterWidth StyleToWidth(JSDurationFormat::Style style) { |
| switch (style) { |
| case JSDurationFormat::Style::kLong: |
| return ULISTFMT_WIDTH_WIDE; |
| case JSDurationFormat::Style::kNarrow: |
| return ULISTFMT_WIDTH_NARROW; |
| case JSDurationFormat::Style::kShort: |
| case JSDurationFormat::Style::kDigital: |
| return ULISTFMT_WIDTH_SHORT; |
| } |
| UNREACHABLE(); |
| } |
| |
| // The last two arguments passed to the Format function is only needed |
| // for Format function to output detail structure and not needed if the |
| // Format only needs to output a String. |
| template <typename T, bool Details, |
| MaybeHandle<T> (*Format)(Isolate*, const icu::FormattedValue&, |
| const std::vector<std::vector<Part>>*, |
| JSDurationFormat::Separator separator)> |
| MaybeHandle<T> PartitionDurationFormatPattern(Isolate* isolate, |
| Handle<JSDurationFormat> df, |
| const DurationRecord& record, |
| const char* method_name) { |
| // 4. Let lfOpts be ! OrdinaryObjectCreate(null). |
| // 5. Perform ! CreateDataPropertyOrThrow(lfOpts, "type", "unit"). |
| UListFormatterType type = ULISTFMT_TYPE_UNITS; |
| // 6. Let listStyle be durationFormat.[[Style]]. |
| // 7. If listStyle is "digital", then |
| // a. Set listStyle to "narrow". |
| // 8. Perform ! CreateDataPropertyOrThrow(lfOpts, "style", listStyle). |
| UListFormatterWidth list_style = StyleToWidth(df->style()); |
| // 9. Let lf be ! Construct(%ListFormat%, « durationFormat.[[Locale]], lfOpts |
| // »). |
| UErrorCode status = U_ZERO_ERROR; |
| icu::Locale icu_locale = *df->icu_locale()->raw(); |
| std::unique_ptr<icu::ListFormatter> formatter( |
| icu::ListFormatter::createInstance(icu_locale, type, list_style, status)); |
| CHECK(U_SUCCESS(status)); |
| |
| std::vector<std::vector<Part>> list; |
| std::vector<std::vector<Part>>* parts = Details ? &list : nullptr; |
| std::vector<icu::UnicodeString> string_list; |
| |
| DurationRecordToListOfFormattedNumber( |
| df, *(df->icu_number_formatter()->raw()), record, parts, &string_list); |
| |
| icu::FormattedList formatted = formatter->formatStringsToValue( |
| string_list.data(), static_cast<int32_t>(string_list.size()), status); |
| CHECK(U_SUCCESS(status)); |
| return Format(isolate, formatted, parts, df->separator()); |
| } |
| |
| // #sec-todurationrecord |
| // ToDurationRecord is almost the same as temporal::ToPartialDuration |
| // except: |
| // 1) In the beginning it will throw RangeError if the type of input is String, |
| // 2) In the end it will throw RangeError if IsValidDurationRecord return false. |
| Maybe<DurationRecord> ToDurationRecord(Isolate* isolate, Handle<Object> input, |
| const DurationRecord& default_value) { |
| // 1-a. If Type(input) is String, throw a RangeError exception. |
| if (IsString(*input)) { |
| THROW_NEW_ERROR_RETURN_VALUE( |
| isolate, |
| NewRangeError(MessageTemplate::kInvalid, |
| isolate->factory()->object_string(), input), |
| Nothing<DurationRecord>()); |
| } |
| // Step 1-b - 23. Same as ToTemporalPartialDurationRecord. |
| DurationRecord record; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, record, |
| temporal::ToPartialDuration(isolate, input, default_value), |
| Nothing<DurationRecord>()); |
| // 24. If IsValidDurationRecord(result) is false, throw a RangeError |
| // exception. |
| if (!temporal::IsValidDuration(isolate, record)) { |
| THROW_NEW_ERROR_RETURN_VALUE( |
| isolate, |
| NewRangeError(MessageTemplate::kInvalid, |
| isolate->factory()->object_string(), input), |
| Nothing<DurationRecord>()); |
| } |
| return Just(record); |
| } |
| |
| template <typename T, bool Details, |
| MaybeHandle<T> (*Format)(Isolate*, const icu::FormattedValue&, |
| const std::vector<std::vector<Part>>*, |
| JSDurationFormat::Separator)> |
| MaybeHandle<T> FormatCommon(Isolate* isolate, Handle<JSDurationFormat> df, |
| Handle<Object> duration, const char* method_name) { |
| // 1. Let df be this value. |
| // 2. Perform ? RequireInternalSlot(df, [[InitializedDurationFormat]]). |
| // 3. Let record be ? ToDurationRecord(duration). |
| DurationRecord record; |
| MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| isolate, record, |
| ToDurationRecord(isolate, duration, {0, 0, 0, {0, 0, 0, 0, 0, 0, 0}}), |
| Handle<T>()); |
| // 5. Let parts be ! PartitionDurationFormatPattern(df, record). |
| return PartitionDurationFormatPattern<T, Details, Format>(isolate, df, record, |
| method_name); |
| } |
| |
| } // namespace |
| |
| MaybeHandle<String> FormattedToString( |
| Isolate* isolate, const icu::FormattedValue& formatted, |
| const std::vector<std::vector<Part>>* parts, JSDurationFormat::Separator) { |
| DCHECK_NULL(parts); |
| return Intl::FormattedToString(isolate, formatted); |
| } |
| |
| MaybeHandle<JSArray> FormattedListToJSArray( |
| Isolate* isolate, const icu::FormattedValue& formatted, |
| const std::vector<std::vector<Part>>* parts, |
| JSDurationFormat::Separator separator) { |
| DCHECK_NOT_NULL(parts); |
| Factory* factory = isolate->factory(); |
| Handle<JSArray> array = factory->NewJSArray(0); |
| icu::ConstrainedFieldPosition cfpos; |
| cfpos.constrainCategory(UFIELD_CATEGORY_LIST); |
| int index = 0; |
| int part_index = 0; |
| UErrorCode status = U_ZERO_ERROR; |
| icu::UnicodeString string = formatted.toString(status); |
| while (formatted.nextPosition(cfpos, status) && U_SUCCESS(status)) { |
| if (cfpos.getField() == ULISTFMT_ELEMENT_FIELD) { |
| for (auto& it : parts->at(part_index++)) { |
| switch (it.part_type) { |
| case Part::Type::kSeparator: { |
| icu::UnicodeString sep(SeparatorToChar(separator)); |
| Handle<String> separator_string; |
| ASSIGN_RETURN_ON_EXCEPTION(isolate, separator_string, |
| Intl::ToString(isolate, sep), JSArray); |
| Intl::AddElement(isolate, array, index++, factory->literal_string(), |
| separator_string); |
| } break; |
| case Part::Type::kFormatted: |
| Handle<String> type_string = |
| factory->NewStringFromAsciiChecked(it.type.c_str()); |
| Maybe<int> index_after_add = Intl::AddNumberElements( |
| isolate, it.formatted, array, index, type_string); |
| MAYBE_RETURN(index_after_add, MaybeHandle<JSArray>()); |
| index = index_after_add.FromJust(); |
| break; |
| } |
| } |
| } else { |
| Handle<String> substring; |
| ASSIGN_RETURN_ON_EXCEPTION( |
| isolate, substring, |
| Intl::ToString(isolate, string, cfpos.getStart(), cfpos.getLimit()), |
| JSArray); |
| Intl::AddElement(isolate, array, index++, factory->literal_string(), |
| substring); |
| } |
| } |
| if (U_FAILURE(status)) { |
| THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kIcuError), JSArray); |
| } |
| JSObject::ValidateElements(*array); |
| return array; |
| } |
| |
| MaybeHandle<String> JSDurationFormat::Format(Isolate* isolate, |
| Handle<JSDurationFormat> df, |
| Handle<Object> duration) { |
| const char* method_name = "Intl.DurationFormat.prototype.format"; |
| return FormatCommon<String, false, FormattedToString>(isolate, df, duration, |
| method_name); |
| } |
| |
| MaybeHandle<JSArray> JSDurationFormat::FormatToParts( |
| Isolate* isolate, Handle<JSDurationFormat> df, Handle<Object> duration) { |
| const char* method_name = "Intl.DurationFormat.prototype.formatToParts"; |
| return FormatCommon<JSArray, true, FormattedListToJSArray>( |
| isolate, df, duration, method_name); |
| } |
| |
| const std::set<std::string>& JSDurationFormat::GetAvailableLocales() { |
| return JSNumberFormat::GetAvailableLocales(); |
| } |
| |
| } // namespace internal |
| } // namespace v8 |
