%PDF-
%PDF-
Mini Shell
Mini Shell
// 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-number-format.h"
#include <set>
#include <string>
#include "src/execution/isolate.h"
#include "src/numbers/conversions.h"
#include "src/objects/intl-objects.h"
#include "src/objects/js-number-format-inl.h"
#include "src/objects/managed-inl.h"
#include "src/objects/objects-inl.h"
#include "src/objects/option-utils.h"
#include "src/strings/char-predicates-inl.h"
#include "unicode/currunit.h"
#include "unicode/locid.h"
#include "unicode/numberformatter.h"
#include "unicode/numberrangeformatter.h"
#include "unicode/numsys.h"
#include "unicode/ucurr.h"
#include "unicode/uloc.h"
#include "unicode/unumberformatter.h"
#include "unicode/uvernum.h" // for U_ICU_VERSION_MAJOR_NUM
namespace v8 {
namespace internal {
namespace {
// This is to work around ICU's comparison operators not being compliant with
// clang's -Wambiguous-reversed-operator in >=C++20.
#define AVOID_AMBIGUOUS_OP_WARNING(x) *static_cast<icu::UObject*>(&x)
// [[Style]] is one of the values "decimal", "percent", "currency",
// or "unit" identifying the style of the number format.
enum class Style { DECIMAL, PERCENT, CURRENCY, UNIT };
// [[CurrencyDisplay]] is one of the values "code", "symbol", "name",
// or "narrowSymbol" identifying the display of the currency number format.
enum class CurrencyDisplay {
CODE,
SYMBOL,
NAME,
NARROW_SYMBOL,
};
// [[CurrencySign]] is one of the String values "standard" or "accounting",
// specifying whether to render negative numbers in accounting format, often
// signified by parenthesis. It is only used when [[Style]] has the value
// "currency" and when [[SignDisplay]] is not "never".
enum class CurrencySign {
STANDARD,
ACCOUNTING,
};
// [[UnitDisplay]] is one of the String values "short", "narrow", or "long",
// specifying whether to display the unit as a symbol, narrow symbol, or
// localized long name if formatting with the "unit" style. It is
// only used when [[Style]] has the value "unit".
enum class UnitDisplay {
SHORT,
NARROW,
LONG,
};
// [[Notation]] is one of the String values "standard", "scientific",
// "engineering", or "compact", specifying whether the number should be
// displayed without scaling, scaled to the units place with the power of ten
// in scientific notation, scaled to the nearest thousand with the power of
// ten in scientific notation, or scaled to the nearest locale-dependent
// compact decimal notation power of ten with the corresponding compact
// decimal notation affix.
enum class Notation {
STANDARD,
SCIENTIFIC,
ENGINEERING,
COMPACT,
};
// [[CompactDisplay]] is one of the String values "short" or "long",
// specifying whether to display compact notation affixes in short form ("5K")
// or long form ("5 thousand") if formatting with the "compact" notation. It
// is only used when [[Notation]] has the value "compact".
enum class CompactDisplay {
SHORT,
LONG,
};
// [[SignDisplay]] is one of the String values "auto", "always", "never", or
// "exceptZero", specifying whether to show the sign on negative numbers
// only, positive and negative numbers including zero, neither positive nor
// negative numbers, or positive and negative numbers but not zero.
enum class SignDisplay {
AUTO,
ALWAYS,
NEVER,
EXCEPT_ZERO,
NEGATIVE,
};
// [[UseGrouping]] is ....
enum class UseGrouping {
OFF,
MIN2,
AUTO,
ALWAYS,
};
UNumberUnitWidth ToUNumberUnitWidth(CurrencyDisplay currency_display) {
switch (currency_display) {
case CurrencyDisplay::SYMBOL:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_SHORT;
case CurrencyDisplay::CODE:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_ISO_CODE;
case CurrencyDisplay::NAME:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME;
case CurrencyDisplay::NARROW_SYMBOL:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW;
}
}
UNumberUnitWidth ToUNumberUnitWidth(UnitDisplay unit_display) {
switch (unit_display) {
case UnitDisplay::SHORT:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_SHORT;
case UnitDisplay::LONG:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME;
case UnitDisplay::NARROW:
return UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW;
}
}
UNumberSignDisplay ToUNumberSignDisplay(SignDisplay sign_display,
CurrencySign currency_sign) {
switch (sign_display) {
case SignDisplay::AUTO:
if (currency_sign == CurrencySign::ACCOUNTING) {
return UNumberSignDisplay::UNUM_SIGN_ACCOUNTING;
}
DCHECK(currency_sign == CurrencySign::STANDARD);
return UNumberSignDisplay::UNUM_SIGN_AUTO;
case SignDisplay::NEVER:
return UNumberSignDisplay::UNUM_SIGN_NEVER;
case SignDisplay::ALWAYS:
if (currency_sign == CurrencySign::ACCOUNTING) {
return UNumberSignDisplay::UNUM_SIGN_ACCOUNTING_ALWAYS;
}
DCHECK(currency_sign == CurrencySign::STANDARD);
return UNumberSignDisplay::UNUM_SIGN_ALWAYS;
case SignDisplay::EXCEPT_ZERO:
if (currency_sign == CurrencySign::ACCOUNTING) {
return UNumberSignDisplay::UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
}
DCHECK(currency_sign == CurrencySign::STANDARD);
return UNumberSignDisplay::UNUM_SIGN_EXCEPT_ZERO;
case SignDisplay::NEGATIVE:
if (currency_sign == CurrencySign::ACCOUNTING) {
return UNumberSignDisplay::UNUM_SIGN_ACCOUNTING_NEGATIVE;
}
DCHECK(currency_sign == CurrencySign::STANDARD);
return UNumberSignDisplay::UNUM_SIGN_NEGATIVE;
}
}
icu::number::Notation ToICUNotation(Notation notation,
CompactDisplay compact_display) {
switch (notation) {
case Notation::STANDARD:
return icu::number::Notation::simple();
case Notation::SCIENTIFIC:
return icu::number::Notation::scientific();
case Notation::ENGINEERING:
return icu::number::Notation::engineering();
// 29. If notation is "compact", then
case Notation::COMPACT:
// 29. a. Set numberFormat.[[CompactDisplay]] to compactDisplay.
if (compact_display == CompactDisplay::SHORT) {
return icu::number::Notation::compactShort();
}
DCHECK(compact_display == CompactDisplay::LONG);
return icu::number::Notation::compactLong();
}
}
UNumberFormatRoundingMode ToUNumberFormatRoundingMode(
Intl::RoundingMode rounding_mode) {
switch (rounding_mode) {
case Intl::RoundingMode::kCeil:
return UNumberFormatRoundingMode::UNUM_ROUND_CEILING;
case Intl::RoundingMode::kFloor:
return UNumberFormatRoundingMode::UNUM_ROUND_FLOOR;
case Intl::RoundingMode::kExpand:
return UNumberFormatRoundingMode::UNUM_ROUND_UP;
case Intl::RoundingMode::kTrunc:
return UNumberFormatRoundingMode::UNUM_ROUND_DOWN;
case Intl::RoundingMode::kHalfCeil:
return UNumberFormatRoundingMode::UNUM_ROUND_HALF_CEILING;
case Intl::RoundingMode::kHalfFloor:
return UNumberFormatRoundingMode::UNUM_ROUND_HALF_FLOOR;
case Intl::RoundingMode::kHalfExpand:
return UNumberFormatRoundingMode::UNUM_ROUND_HALFUP;
case Intl::RoundingMode::kHalfTrunc:
return UNumberFormatRoundingMode::UNUM_ROUND_HALFDOWN;
case Intl::RoundingMode::kHalfEven:
return UNumberFormatRoundingMode::UNUM_ROUND_HALFEVEN;
}
}
UNumberGroupingStrategy ToUNumberGroupingStrategy(UseGrouping use_grouping) {
switch (use_grouping) {
case UseGrouping::OFF:
return UNumberGroupingStrategy::UNUM_GROUPING_OFF;
case UseGrouping::MIN2:
return UNumberGroupingStrategy::UNUM_GROUPING_MIN2;
case UseGrouping::AUTO:
return UNumberGroupingStrategy::UNUM_GROUPING_AUTO;
case UseGrouping::ALWAYS:
return UNumberGroupingStrategy::UNUM_GROUPING_ON_ALIGNED;
}
}
std::map<const std::string, icu::MeasureUnit> CreateUnitMap() {
UErrorCode status = U_ZERO_ERROR;
int32_t total = icu::MeasureUnit::getAvailable(nullptr, 0, status);
DCHECK(U_FAILURE(status));
status = U_ZERO_ERROR;
std::vector<icu::MeasureUnit> units(total);
total = icu::MeasureUnit::getAvailable(units.data(), total, status);
DCHECK(U_SUCCESS(status));
std::map<const std::string, icu::MeasureUnit> map;
std::set<std::string> sanctioned(Intl::SanctionedSimpleUnits());
for (auto it = units.begin(); it != units.end(); ++it) {
// Need to skip none/percent
if (sanctioned.count(it->getSubtype()) > 0 &&
strcmp("none", it->getType()) != 0) {
map[it->getSubtype()] = *it;
}
}
return map;
}
class UnitFactory {
public:
UnitFactory() : map_(CreateUnitMap()) {}
virtual ~UnitFactory() = default;
// ecma402 #sec-issanctionedsimpleunitidentifier
icu::MeasureUnit create(const std::string& unitIdentifier) {
// 1. If unitIdentifier is in the following list, return true.
auto found = map_.find(unitIdentifier);
if (found != map_.end()) {
return found->second;
}
// 2. Return false.
return icu::MeasureUnit();
}
private:
std::map<const std::string, icu::MeasureUnit> map_;
};
// ecma402 #sec-issanctionedsimpleunitidentifier
icu::MeasureUnit IsSanctionedUnitIdentifier(const std::string& unit) {
static base::LazyInstance<UnitFactory>::type factory =
LAZY_INSTANCE_INITIALIZER;
return factory.Pointer()->create(unit);
}
// ecma402 #sec-iswellformedunitidentifier
Maybe<std::pair<icu::MeasureUnit, icu::MeasureUnit>> IsWellFormedUnitIdentifier(
Isolate* isolate, const std::string& unit) {
icu::MeasureUnit result = IsSanctionedUnitIdentifier(unit);
icu::MeasureUnit none = icu::MeasureUnit();
// 1. If the result of IsSanctionedUnitIdentifier(unitIdentifier) is true,
// then
if (result != AVOID_AMBIGUOUS_OP_WARNING(none)) {
// a. Return true.
std::pair<icu::MeasureUnit, icu::MeasureUnit> pair(result, none);
return Just(pair);
}
// 2. If the substring "-per-" does not occur exactly once in unitIdentifier,
// then
size_t first_per = unit.find("-per-");
if (first_per == std::string::npos ||
unit.find("-per-", first_per + 5) != std::string::npos) {
// a. Return false.
return Nothing<std::pair<icu::MeasureUnit, icu::MeasureUnit>>();
}
// 3. Let numerator be the substring of unitIdentifier from the beginning to
// just before "-per-".
std::string numerator = unit.substr(0, first_per);
// 4. If the result of IsSanctionedUnitIdentifier(numerator) is false, then
result = IsSanctionedUnitIdentifier(numerator);
if (result == AVOID_AMBIGUOUS_OP_WARNING(none)) {
// a. Return false.
return Nothing<std::pair<icu::MeasureUnit, icu::MeasureUnit>>();
}
// 5. Let denominator be the substring of unitIdentifier from just after
// "-per-" to the end.
std::string denominator = unit.substr(first_per + 5);
// 6. If the result of IsSanctionedUnitIdentifier(denominator) is false, then
icu::MeasureUnit den_result = IsSanctionedUnitIdentifier(denominator);
if (den_result == AVOID_AMBIGUOUS_OP_WARNING(none)) {
// a. Return false.
return Nothing<std::pair<icu::MeasureUnit, icu::MeasureUnit>>();
}
// 7. Return true.
std::pair<icu::MeasureUnit, icu::MeasureUnit> pair(result, den_result);
return Just(pair);
}
// ecma-402/#sec-currencydigits
// The currency is expected to an all upper case string value.
int CurrencyDigits(const icu::UnicodeString& currency) {
UErrorCode status = U_ZERO_ERROR;
uint32_t fraction_digits = ucurr_getDefaultFractionDigits(
reinterpret_cast<const UChar*>(currency.getBuffer()), &status);
// For missing currency codes, default to the most common, 2
return U_SUCCESS(status) ? fraction_digits : 2;
}
bool IsAToZ(char ch) {
return base::IsInRange(AsciiAlphaToLower(ch), 'a', 'z');
}
// ecma402/#sec-iswellformedcurrencycode
bool IsWellFormedCurrencyCode(const std::string& currency) {
// Verifies that the input is a well-formed ISO 4217 currency code.
// ecma402/#sec-currency-codes
// 2. If the number of elements in normalized is not 3, return false.
if (currency.length() != 3) return false;
// 1. Let normalized be the result of mapping currency to upper case as
// described in 6.1.
//
// 3. If normalized contains any character that is not in
// the range "A" to "Z" (U+0041 to U+005A), return false.
//
// 4. Return true.
// Don't uppercase to test. It could convert invalid code into a valid one.
// For example \u00DFP (Eszett+P) becomes SSP.
return (IsAToZ(currency[0]) && IsAToZ(currency[1]) && IsAToZ(currency[2]));
}
// Return the style as a String.
Handle<String> StyleAsString(Isolate* isolate, Style style) {
switch (style) {
case Style::PERCENT:
return ReadOnlyRoots(isolate).percent_string_handle();
case Style::CURRENCY:
return ReadOnlyRoots(isolate).currency_string_handle();
case Style::UNIT:
return ReadOnlyRoots(isolate).unit_string_handle();
case Style::DECIMAL:
return ReadOnlyRoots(isolate).decimal_string_handle();
}
UNREACHABLE();
}
// Parse the 'currencyDisplay' from the skeleton.
Handle<String> CurrencyDisplayString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
// Ex: skeleton as
// "currency/TWD .00 rounding-mode-half-up unit-width-iso-code"
if (skeleton.indexOf("unit-width-iso-code") >= 0) {
return ReadOnlyRoots(isolate).code_string_handle();
}
// Ex: skeleton as
// "currency/TWD .00 rounding-mode-half-up unit-width-full-name;"
if (skeleton.indexOf("unit-width-full-name") >= 0) {
return ReadOnlyRoots(isolate).name_string_handle();
}
// Ex: skeleton as
// "currency/TWD .00 rounding-mode-half-up unit-width-narrow;
if (skeleton.indexOf("unit-width-narrow") >= 0) {
return ReadOnlyRoots(isolate).narrowSymbol_string_handle();
}
// Ex: skeleton as "currency/TWD .00 rounding-mode-half-up"
return ReadOnlyRoots(isolate).symbol_string_handle();
}
Handle<Object> UseGroupingFromSkeleton(Isolate* isolate,
const icu::UnicodeString& skeleton) {
Factory* factory = isolate->factory();
static const char* group = "group-";
int32_t start = skeleton.indexOf(group);
if (start >= 0) {
DCHECK_EQ(6, strlen(group));
icu::UnicodeString check = skeleton.tempSubString(start + 6);
// Ex: skeleton as
// .### rounding-mode-half-up group-off
if (check.startsWith("off")) {
return factory->false_value();
}
// Ex: skeleton as
// .### rounding-mode-half-up group-min2
if (check.startsWith("min2")) {
return ReadOnlyRoots(isolate).min2_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-half-up group-on-aligned
if (check.startsWith("on-aligned")) {
return ReadOnlyRoots(isolate).always_string_handle();
}
}
// Ex: skeleton as
// .###
return ReadOnlyRoots(isolate).auto_string_handle();
}
// Parse currency code from skeleton. For example, skeleton as
// "currency/TWD .00 rounding-mode-half-up unit-width-full-name;"
const icu::UnicodeString CurrencyFromSkeleton(
const icu::UnicodeString& skeleton) {
const char currency[] = "currency/";
int32_t index = skeleton.indexOf(currency);
if (index < 0) return "";
index += static_cast<int32_t>(std::strlen(currency));
return skeleton.tempSubString(index, 3);
}
} // namespace
const icu::UnicodeString JSNumberFormat::NumberingSystemFromSkeleton(
const icu::UnicodeString& skeleton) {
const char numbering_system[] = "numbering-system/";
int32_t index = skeleton.indexOf(numbering_system);
if (index < 0) return "latn";
index += static_cast<int32_t>(std::strlen(numbering_system));
const icu::UnicodeString res = skeleton.tempSubString(index);
index = res.indexOf(" ");
if (index < 0) return res;
return res.tempSubString(0, index);
}
namespace {
// Return CurrencySign as string based on skeleton.
Handle<String> CurrencySignString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
// Ex: skeleton as
// "currency/TWD .00 rounding-mode-half-up sign-accounting-always" OR
// "currency/TWD .00 rounding-mode-half-up sign-accounting-except-zero"
if (skeleton.indexOf("sign-accounting") >= 0) {
return ReadOnlyRoots(isolate).accounting_string_handle();
}
return ReadOnlyRoots(isolate).standard_string_handle();
}
// Return UnitDisplay as string based on skeleton.
Handle<String> UnitDisplayString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
// Ex: skeleton as
// "unit/length-meter .### rounding-mode-half-up unit-width-full-name"
if (skeleton.indexOf("unit-width-full-name") >= 0) {
return ReadOnlyRoots(isolate).long_string_handle();
}
// Ex: skeleton as
// "unit/length-meter .### rounding-mode-half-up unit-width-narrow".
if (skeleton.indexOf("unit-width-narrow") >= 0) {
return ReadOnlyRoots(isolate).narrow_string_handle();
}
// Ex: skeleton as
// "unit/length-foot .### rounding-mode-half-up"
return ReadOnlyRoots(isolate).short_string_handle();
}
// Parse Notation from skeleton.
Notation NotationFromSkeleton(const icu::UnicodeString& skeleton) {
// Ex: skeleton as
// "scientific .### rounding-mode-half-up"
if (skeleton.indexOf("scientific") >= 0) {
return Notation::SCIENTIFIC;
}
// Ex: skeleton as
// "engineering .### rounding-mode-half-up"
if (skeleton.indexOf("engineering") >= 0) {
return Notation::ENGINEERING;
}
// Ex: skeleton as
// "compact-short .### rounding-mode-half-up" or
// "compact-long .### rounding-mode-half-up
if (skeleton.indexOf("compact-") >= 0) {
return Notation::COMPACT;
}
// Ex: skeleton as
// "unit/length-foot .### rounding-mode-half-up"
return Notation::STANDARD;
}
Handle<String> NotationAsString(Isolate* isolate, Notation notation) {
switch (notation) {
case Notation::SCIENTIFIC:
return ReadOnlyRoots(isolate).scientific_string_handle();
case Notation::ENGINEERING:
return ReadOnlyRoots(isolate).engineering_string_handle();
case Notation::COMPACT:
return ReadOnlyRoots(isolate).compact_string_handle();
case Notation::STANDARD:
return ReadOnlyRoots(isolate).standard_string_handle();
}
UNREACHABLE();
}
// Return CompactString as string based on skeleton.
Handle<String> CompactDisplayString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
// Ex: skeleton as
// "compact-long .### rounding-mode-half-up"
if (skeleton.indexOf("compact-long") >= 0) {
return ReadOnlyRoots(isolate).long_string_handle();
}
// Ex: skeleton as
// "compact-short .### rounding-mode-half-up"
DCHECK_GE(skeleton.indexOf("compact-short"), 0);
return ReadOnlyRoots(isolate).short_string_handle();
}
// Return SignDisplay as string based on skeleton.
Handle<String> SignDisplayString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
// Ex: skeleton as
// "currency/TWD .00 rounding-mode-half-up sign-never"
if (skeleton.indexOf("sign-never") >= 0) {
return ReadOnlyRoots(isolate).never_string_handle();
}
// Ex: skeleton as
// ".### rounding-mode-half-up sign-always" or
// "currency/TWD .00 rounding-mode-half-up sign-accounting-always"
if (skeleton.indexOf("sign-always") >= 0 ||
skeleton.indexOf("sign-accounting-always") >= 0) {
return ReadOnlyRoots(isolate).always_string_handle();
}
// Ex: skeleton as
// "currency/TWD .00 rounding-mode-half-up sign-accounting-except-zero" or
// "currency/TWD .00 rounding-mode-half-up sign-except-zero"
if (skeleton.indexOf("sign-accounting-except-zero") >= 0 ||
skeleton.indexOf("sign-except-zero") >= 0) {
return ReadOnlyRoots(isolate).exceptZero_string_handle();
}
// Ex: skeleton as
// ".### rounding-mode-half-up sign-negative" or
// "currency/TWD .00 rounding-mode-half-up sign-accounting-negative"
if (skeleton.indexOf("sign-accounting-negative") >= 0 ||
skeleton.indexOf("sign-negative") >= 0) {
return ReadOnlyRoots(isolate).negative_string_handle();
}
return ReadOnlyRoots(isolate).auto_string_handle();
}
// Return RoundingMode as string based on skeleton.
Handle<String> RoundingModeString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
static const char* rounding_mode = "rounding-mode-";
int32_t start = skeleton.indexOf(rounding_mode);
if (start >= 0) {
DCHECK_EQ(14, strlen(rounding_mode));
icu::UnicodeString check = skeleton.tempSubString(start + 14);
// Ex: skeleton as
// .### rounding-mode-ceiling
if (check.startsWith("ceiling")) {
return ReadOnlyRoots(isolate).ceil_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-down
if (check.startsWith("down")) {
return ReadOnlyRoots(isolate).trunc_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-floor
if (check.startsWith("floor")) {
return ReadOnlyRoots(isolate).floor_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-half-ceiling
if (check.startsWith("half-ceiling")) {
return ReadOnlyRoots(isolate).halfCeil_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-half-down
if (check.startsWith("half-down")) {
return ReadOnlyRoots(isolate).halfTrunc_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-half-floor
if (check.startsWith("half-floor")) {
return ReadOnlyRoots(isolate).halfFloor_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-half-up
if (check.startsWith("half-up")) {
return ReadOnlyRoots(isolate).halfExpand_string_handle();
}
// Ex: skeleton as
// .### rounding-mode-up
if (check.startsWith("up")) {
return ReadOnlyRoots(isolate).expand_string_handle();
}
}
// Ex: skeleton as
// .###
return ReadOnlyRoots(isolate).halfEven_string_handle();
}
Handle<Object> RoundingIncrement(Isolate* isolate,
const icu::UnicodeString& skeleton) {
int32_t cur = skeleton.indexOf(u"precision-increment/");
if (cur < 0) return isolate->factory()->NewNumberFromInt(1);
cur += 20; // length of "precision-increment/"
int32_t increment = 0;
while (cur < skeleton.length()) {
char16_t c = skeleton[cur++];
if (c == u'.') continue;
if (!IsDecimalDigit(c)) break;
increment = increment * 10 + (c - '0');
}
return isolate->factory()->NewNumberFromInt(increment);
}
// Return RoundingPriority as string based on skeleton.
Handle<String> RoundingPriorityString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
int32_t found;
// If #r or @r is followed by a SPACE or in the end of line.
if ((found = skeleton.indexOf("#r")) >= 0 ||
(found = skeleton.indexOf("@r")) >= 0) {
if (found + 2 == skeleton.length() || skeleton[found + 2] == ' ') {
return ReadOnlyRoots(isolate).morePrecision_string_handle();
}
}
// If #s or @s is followed by a SPACE or in the end of line.
if ((found = skeleton.indexOf("#s")) >= 0 ||
(found = skeleton.indexOf("@s")) >= 0) {
if (found + 2 == skeleton.length() || skeleton[found + 2] == ' ') {
return ReadOnlyRoots(isolate).lessPrecision_string_handle();
}
}
return ReadOnlyRoots(isolate).auto_string_handle();
}
// Return trailingZeroDisplay as string based on skeleton.
Handle<String> TrailingZeroDisplayString(Isolate* isolate,
const icu::UnicodeString& skeleton) {
int32_t found;
if ((found = skeleton.indexOf("/w")) >= 0) {
if (found + 2 == skeleton.length() || skeleton[found + 2] == ' ') {
return ReadOnlyRoots(isolate).stripIfInteger_string_handle();
}
}
return ReadOnlyRoots(isolate).auto_string_handle();
}
} // anonymous namespace
// Return the minimum integer digits by counting the number of '0' after
// "integer-width/*" in the skeleton.
// Ex: Return 15 for skeleton as
// “currency/TWD .00 rounding-mode-half-up integer-width/*000000000000000”
// 1
// 123456789012345
// Return default value as 1 if there are no "integer-width/*".
int32_t JSNumberFormat::MinimumIntegerDigitsFromSkeleton(
const icu::UnicodeString& skeleton) {
// count the number of 0 after "integer-width/*"
icu::UnicodeString search("integer-width/*");
int32_t index = skeleton.indexOf(search);
if (index < 0) return 1; // return 1 if cannot find it.
index += search.length();
int32_t matched = 0;
while (index < skeleton.length() && skeleton[index] == '0') {
matched++;
index++;
}
DCHECK_GT(matched, 0);
return matched;
}
// Return true if there are fraction digits, false if not.
// The minimum fraction digits is the number of '0' after '.' in the skeleton
// The maximum fraction digits is the number of '#' after the above '0's plus
// the minimum fraction digits.
// For example, as skeleton “.000#### rounding-mode-half-up”
// 123
// 4567
// Set The minimum as 3 and maximum as 7.
// We also treat the following special cases as both minimum and maximum are 0
// while there are no . in the skeleton:
// 1. While there are "precision-integer" in the skeleton.
// 2. While there are "precision-increment/" in the skeleton but no . after it.
// Examples:
// "currency/JPY precision-integer rounding-mode-half-up"
// "precision-increment/2 rounding-mode-half-up"
bool JSNumberFormat::FractionDigitsFromSkeleton(
const icu::UnicodeString& skeleton, int32_t* minimum, int32_t* maximum) {
int32_t index = skeleton.indexOf(".");
if (index < 0) {
// https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#precision
// Note that the stem . is considered valid and is equivalent to
// precision-integer.
// Also, if there are "precision-increment/" but no "." we consider both
// minimum and maximum fraction digits as 0.
if (skeleton.indexOf("precision-integer") >= 0 ||
skeleton.indexOf("precision-increment/") >= 0) {
*minimum = *maximum = 0;
return true;
}
return false;
}
*minimum = 0;
index++; // skip the '.'
while (index < skeleton.length() && IsDecimalDigit(skeleton[index])) {
(*minimum)++;
index++;
}
*maximum = *minimum;
while (index < skeleton.length() && skeleton[index] == '#') {
(*maximum)++;
index++;
}
return true;
}
// Return true if there are significant digits, false if not.
// The minimum significant digits is the number of '@' in the skeleton
// The maximum significant digits is the number of '#' after these '@'s plus
// the minimum significant digits.
// Ex: Skeleton as "@@@@@####### rounding-mode-half-up"
// 12345
// 6789012
// Set The minimum as 5 and maximum as 12.
bool JSNumberFormat::SignificantDigitsFromSkeleton(
const icu::UnicodeString& skeleton, int32_t* minimum, int32_t* maximum) {
int32_t index = skeleton.indexOf("@");
if (index < 0) return false;
*minimum = 1;
index++; // skip the first '@'
while (index < skeleton.length() && skeleton[index] == '@') {
(*minimum)++;
index++;
}
*maximum = *minimum;
while (index < skeleton.length() && skeleton[index] == '#') {
(*maximum)++;
index++;
}
return true;
}
namespace {
// Ex: percent .### rounding-mode-half-up
// Special case for "percent"
// Ex: "unit/milliliter-per-acre .### rounding-mode-half-up"
// should return "milliliter-per-acre".
// Ex: "unit/year .### rounding-mode-half-up" should return
// "year".
std::string UnitFromSkeleton(const icu::UnicodeString& skeleton) {
std::string str;
str = skeleton.toUTF8String<std::string>(str);
std::string search("unit/");
size_t begin = str.find(search);
if (begin == str.npos) {
// Special case for "percent".
if (str.find("percent") != str.npos) {
return "percent";
}
return "";
}
// Ex:
// "unit/acre .### rounding-mode-half-up"
// b
// Ex:
// "unit/milliliter-per-acre .### rounding-mode-half-up"
// b
begin += search.size();
if (begin == str.npos) {
return "";
}
// Find the end of the subtype.
size_t end = str.find(" ", begin);
// Ex:
// "unit/acre .### rounding-mode-half-up"
// b e
// Ex:
// "unit/milliliter-per-acre .### rounding-mode-half-up"
// b e
if (end == str.npos) {
end = str.size();
}
return str.substr(begin, end - begin);
}
Style StyleFromSkeleton(const icu::UnicodeString& skeleton) {
if (skeleton.indexOf("currency/") >= 0) {
return Style::CURRENCY;
}
if (skeleton.indexOf("percent") >= 0) {
// percent precision-integer rounding-mode-half-up scale/100
if (skeleton.indexOf("scale/100") >= 0) {
return Style::PERCENT;
} else {
return Style::UNIT;
}
}
// Before ICU68: "measure-unit/", since ICU68 "unit/"
if (skeleton.indexOf("unit/") >= 0) {
return Style::UNIT;
}
return Style::DECIMAL;
}
} // anonymous namespace
icu::number::UnlocalizedNumberFormatter
JSNumberFormat::SetDigitOptionsToFormatter(
const icu::number::UnlocalizedNumberFormatter& settings,
const Intl::NumberFormatDigitOptions& digit_options) {
icu::number::UnlocalizedNumberFormatter result = settings.roundingMode(
ToUNumberFormatRoundingMode(digit_options.rounding_mode));
if (digit_options.minimum_integer_digits > 1) {
result = result.integerWidth(icu::number::IntegerWidth::zeroFillTo(
digit_options.minimum_integer_digits));
}
icu::number::Precision precision = icu::number::Precision::unlimited();
bool relaxed = false;
switch (digit_options.rounding_type) {
case Intl::RoundingType::kSignificantDigits:
precision = icu::number::Precision::minMaxSignificantDigits(
digit_options.minimum_significant_digits,
digit_options.maximum_significant_digits);
break;
case Intl::RoundingType::kFractionDigits:
precision = icu::number::Precision::minMaxFraction(
digit_options.minimum_fraction_digits,
digit_options.maximum_fraction_digits);
break;
case Intl::RoundingType::kMorePrecision:
relaxed = true;
V8_FALLTHROUGH;
case Intl::RoundingType::kLessPrecision:
precision =
icu::number::Precision::minMaxFraction(
digit_options.minimum_fraction_digits,
digit_options.maximum_fraction_digits)
.withSignificantDigits(digit_options.minimum_significant_digits,
digit_options.maximum_significant_digits,
relaxed ? UNUM_ROUNDING_PRIORITY_RELAXED
: UNUM_ROUNDING_PRIORITY_STRICT);
break;
}
if (digit_options.rounding_increment != 1) {
precision = ::icu::number::Precision::incrementExact(
digit_options.rounding_increment,
-digit_options.maximum_fraction_digits)
.withMinFraction(digit_options.minimum_fraction_digits);
}
if (digit_options.trailing_zero_display ==
Intl::TrailingZeroDisplay::kStripIfInteger) {
precision = precision.trailingZeroDisplay(UNUM_TRAILING_ZERO_HIDE_IF_WHOLE);
}
return result.precision(precision);
}
// static
// ecma402 #sec-intl.numberformat.prototype.resolvedoptions
Handle<JSObject> JSNumberFormat::ResolvedOptions(
Isolate* isolate, Handle<JSNumberFormat> number_format) {
Factory* factory = isolate->factory();
UErrorCode status = U_ZERO_ERROR;
icu::number::LocalizedNumberFormatter* fmt =
number_format->icu_number_formatter()->raw();
icu::UnicodeString skeleton = fmt->toSkeleton(status);
DCHECK(U_SUCCESS(status));
// 4. Let options be ! ObjectCreate(%ObjectPrototype%).
Handle<JSObject> options = factory->NewJSObject(isolate->object_function());
Handle<String> locale = Handle<String>(number_format->locale(), isolate);
const icu::UnicodeString numberingSystem_ustr =
JSNumberFormat::NumberingSystemFromSkeleton(skeleton);
// 5. For each row of Table 4, except the header row, in table order, do
// Table 4: Resolved Options of NumberFormat Instances
// Internal Slot Property
// [[Locale]] "locale"
// [[NumberingSystem]] "numberingSystem"
// [[Style]] "style"
// [[Currency]] "currency"
// [[CurrencyDisplay]] "currencyDisplay"
// [[CurrencySign]] "currencySign"
// [[Unit]] "unit"
// [[UnitDisplay]] "unitDisplay"
// [[MinimumIntegerDigits]] "minimumIntegerDigits"
// [[MinimumFractionDigits]] "minimumFractionDigits"
// [[MaximumFractionDigits]] "maximumFractionDigits"
// [[MinimumSignificantDigits]] "minimumSignificantDigits"
// [[MaximumSignificantDigits]] "maximumSignificantDigits"
// [[UseGrouping]] "useGrouping"
// [[Notation]] "notation"
// [[CompactDisplay]] "compactDisplay"
// [[SignDisplay]] "signDisplay"
// [[RoundingMode]] "roundingMode"
// [[RoundingIncrement]] "roundingIncrement"
// [[TrailingZeroDisplay]] "trailingZeroDisplay"
CHECK(JSReceiver::CreateDataProperty(isolate, options,
factory->locale_string(), locale,
Just(kDontThrow))
.FromJust());
Handle<String> numberingSystem_string;
CHECK(Intl::ToString(isolate, numberingSystem_ustr)
.ToHandle(&numberingSystem_string));
CHECK(JSReceiver::CreateDataProperty(isolate, options,
factory->numberingSystem_string(),
numberingSystem_string, Just(kDontThrow))
.FromJust());
Style style = StyleFromSkeleton(skeleton);
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->style_string(),
StyleAsString(isolate, style), Just(kDontThrow))
.FromJust());
const icu::UnicodeString currency_ustr = CurrencyFromSkeleton(skeleton);
if (!currency_ustr.isEmpty()) {
Handle<String> currency_string;
CHECK(Intl::ToString(isolate, currency_ustr).ToHandle(¤cy_string));
CHECK(JSReceiver::CreateDataProperty(isolate, options,
factory->currency_string(),
currency_string, Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->currencyDisplay_string(),
CurrencyDisplayString(isolate, skeleton), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->currencySign_string(),
CurrencySignString(isolate, skeleton), Just(kDontThrow))
.FromJust());
}
if (style == Style::UNIT) {
std::string unit = UnitFromSkeleton(skeleton);
if (!unit.empty()) {
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->unit_string(),
isolate->factory()->NewStringFromAsciiChecked(unit.c_str()),
Just(kDontThrow))
.FromJust());
}
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->unitDisplay_string(),
UnitDisplayString(isolate, skeleton), Just(kDontThrow))
.FromJust());
}
CHECK(
JSReceiver::CreateDataProperty(
isolate, options, factory->minimumIntegerDigits_string(),
factory->NewNumberFromInt(MinimumIntegerDigitsFromSkeleton(skeleton)),
Just(kDontThrow))
.FromJust());
int32_t mnsd = 0, mxsd = 0, mnfd = 0, mxfd = 0;
bool has_significant_digits =
SignificantDigitsFromSkeleton(skeleton, &mnsd, &mxsd);
if (has_significant_digits) {
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->minimumSignificantDigits_string(),
factory->NewNumberFromInt(mnsd), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->maximumSignificantDigits_string(),
factory->NewNumberFromInt(mxsd), Just(kDontThrow))
.FromJust());
}
if (FractionDigitsFromSkeleton(skeleton, &mnfd, &mxfd)) {
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->minimumFractionDigits_string(),
factory->NewNumberFromInt(mnfd), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->maximumFractionDigits_string(),
factory->NewNumberFromInt(mxfd), Just(kDontThrow))
.FromJust());
}
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->useGrouping_string(),
UseGroupingFromSkeleton(isolate, skeleton), Just(kDontThrow))
.FromJust());
Notation notation = NotationFromSkeleton(skeleton);
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->notation_string(),
NotationAsString(isolate, notation), Just(kDontThrow))
.FromJust());
// Only output compactDisplay when notation is compact.
if (notation == Notation::COMPACT) {
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->compactDisplay_string(),
CompactDisplayString(isolate, skeleton), Just(kDontThrow))
.FromJust());
}
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->signDisplay_string(),
SignDisplayString(isolate, skeleton), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->roundingMode_string(),
RoundingModeString(isolate, skeleton), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->roundingIncrement_string(),
RoundingIncrement(isolate, skeleton), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->roundingPriority_string(),
RoundingPriorityString(isolate, skeleton), Just(kDontThrow))
.FromJust());
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->trailingZeroDisplay_string(),
TrailingZeroDisplayString(isolate, skeleton), Just(kDontThrow))
.FromJust());
return options;
}
// ecma402/#sec-unwrapnumberformat
MaybeHandle<JSNumberFormat> JSNumberFormat::UnwrapNumberFormat(
Isolate* isolate, Handle<JSReceiver> format_holder) {
// old code copy from NumberFormat::Unwrap that has no spec comment and
// compiled but fail unit tests.
Handle<Context> native_context =
Handle<Context>(isolate->context()->native_context(), isolate);
Handle<JSFunction> constructor = Handle<JSFunction>(
JSFunction::cast(native_context->intl_number_format_function()), isolate);
Handle<Object> object;
ASSIGN_RETURN_ON_EXCEPTION(
isolate, object,
Intl::LegacyUnwrapReceiver(isolate, format_holder, constructor,
IsJSNumberFormat(*format_holder)),
JSNumberFormat);
// 4. If ... or nf does not have an [[InitializedNumberFormat]] internal slot,
// then
if (!IsJSNumberFormat(*object)) {
// a. Throw a TypeError exception.
THROW_NEW_ERROR(isolate,
NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
isolate->factory()->NewStringFromAsciiChecked(
"UnwrapNumberFormat")),
JSNumberFormat);
}
// 5. Return nf.
return Handle<JSNumberFormat>::cast(object);
}
// static
MaybeHandle<JSNumberFormat> JSNumberFormat::New(Isolate* isolate,
Handle<Map> map,
Handle<Object> locales,
Handle<Object> options_obj,
const char* service) {
Factory* factory = isolate->factory();
// 1. Let requestedLocales be ? CanonicalizeLocaleList(locales).
Maybe<std::vector<std::string>> maybe_requested_locales =
Intl::CanonicalizeLocaleList(isolate, locales);
MAYBE_RETURN(maybe_requested_locales, Handle<JSNumberFormat>());
std::vector<std::string> requested_locales =
maybe_requested_locales.FromJust();
// 2. Set options to ? CoerceOptionsToObject(options).
Handle<JSReceiver> options;
ASSIGN_RETURN_ON_EXCEPTION(
isolate, options, CoerceOptionsToObject(isolate, options_obj, service),
JSNumberFormat);
// 3. Let opt be a new Record.
// 4. Let matcher be ? GetOption(options, "localeMatcher", "string", «
// "lookup", "best fit" », "best fit").
// 5. Set opt.[[localeMatcher]] to matcher.
Maybe<Intl::MatcherOption> maybe_locale_matcher =
Intl::GetLocaleMatcher(isolate, options, service);
MAYBE_RETURN(maybe_locale_matcher, MaybeHandle<JSNumberFormat>());
Intl::MatcherOption matcher = maybe_locale_matcher.FromJust();
std::unique_ptr<char[]> numbering_system_str = nullptr;
// 6. Let _numberingSystem_ be ? GetOption(_options_, `"numberingSystem"`,
// `"string"`, *undefined*, *undefined*).
Maybe<bool> maybe_numberingSystem = Intl::GetNumberingSystem(
isolate, options, service, &numbering_system_str);
// 7. If _numberingSystem_ is not *undefined*, then
// 8. If _numberingSystem_ does not match the
// `(3*8alphanum) *("-" (3*8alphanum))` sequence, throw a *RangeError*
// exception.
MAYBE_RETURN(maybe_numberingSystem, MaybeHandle<JSNumberFormat>());
// 9. Let localeData be %NumberFormat%.[[LocaleData]].
// 10. Let r be ResolveLocale(%NumberFormat%.[[AvailableLocales]],
// requestedLocales, opt, %NumberFormat%.[[RelevantExtensionKeys]],
// localeData).
std::set<std::string> relevant_extension_keys{"nu"};
Maybe<Intl::ResolvedLocale> maybe_resolve_locale =
Intl::ResolveLocale(isolate, JSNumberFormat::GetAvailableLocales(),
requested_locales, matcher, relevant_extension_keys);
if (maybe_resolve_locale.IsNothing()) {
THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kIcuError),
JSNumberFormat);
}
Intl::ResolvedLocale r = maybe_resolve_locale.FromJust();
icu::Locale icu_locale = r.icu_locale;
UErrorCode status = U_ZERO_ERROR;
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));
}
}
// 9. Set numberFormat.[[Locale]] to r.[[locale]].
Maybe<std::string> maybe_locale_str = Intl::ToLanguageTag(icu_locale);
MAYBE_RETURN(maybe_locale_str, MaybeHandle<JSNumberFormat>());
Handle<String> locale_str = isolate->factory()->NewStringFromAsciiChecked(
maybe_locale_str.FromJust().c_str());
if (numbering_system_str != nullptr &&
Intl::IsValidNumberingSystem(numbering_system_str.get())) {
icu_locale.setUnicodeKeywordValue("nu", numbering_system_str.get(), status);
DCHECK(U_SUCCESS(status));
}
std::string numbering_system = Intl::GetNumberingSystem(icu_locale);
// 11. Let dataLocale be r.[[dataLocale]].
icu::number::UnlocalizedNumberFormatter settings =
icu::number::UnlocalizedNumberFormatter().roundingMode(UNUM_ROUND_HALFUP);
// For 'latn' numbering system, skip the adoptSymbols which would cause
// 10.1%-13.7% of regression of JSTests/Intl-NewIntlNumberFormat
// See crbug/1052751 so we skip calling adoptSymbols and depending on the
// default instead.
if (!numbering_system.empty() && numbering_system != "latn") {
settings = settings.adoptSymbols(icu::NumberingSystem::createInstanceByName(
numbering_system.c_str(), status));
DCHECK(U_SUCCESS(status));
}
// ==== Start SetNumberFormatUnitOptions ====
// 3. Let style be ? GetOption(options, "style", "string", « "decimal",
// "percent", "currency", "unit" », "decimal").
Maybe<Style> maybe_style = GetStringOption<Style>(
isolate, options, "style", service,
{"decimal", "percent", "currency", "unit"},
{Style::DECIMAL, Style::PERCENT, Style::CURRENCY, Style::UNIT},
Style::DECIMAL);
MAYBE_RETURN(maybe_style, MaybeHandle<JSNumberFormat>());
Style style = maybe_style.FromJust();
// 4. Set intlObj.[[Style]] to style.
// 5. Let currency be ? GetOption(options, "currency", "string", undefined,
// undefined).
std::unique_ptr<char[]> currency_cstr;
const std::vector<const char*> empty_values = {};
Maybe<bool> found_currency = GetStringOption(
isolate, options, "currency", empty_values, service, ¤cy_cstr);
MAYBE_RETURN(found_currency, MaybeHandle<JSNumberFormat>());
std::string currency;
// 6. If currency is not undefined, then
if (found_currency.FromJust()) {
DCHECK_NOT_NULL(currency_cstr.get());
currency = currency_cstr.get();
// 6. a. If the result of IsWellFormedCurrencyCode(currency) is false,
// throw a RangeError exception.
if (!IsWellFormedCurrencyCode(currency)) {
THROW_NEW_ERROR(
isolate,
NewRangeError(MessageTemplate::kInvalid,
factory->NewStringFromStaticChars("currency code"),
factory->NewStringFromAsciiChecked(currency.c_str())),
JSNumberFormat);
}
} else {
// 7. If style is "currency" and currency is undefined, throw a TypeError
// exception.
if (style == Style::CURRENCY) {
THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kCurrencyCode),
JSNumberFormat);
}
}
// 8. Let currencyDisplay be ? GetOption(options, "currencyDisplay",
// "string", « "code", "symbol", "name", "narrowSymbol" », "symbol").
Maybe<CurrencyDisplay> maybe_currency_display =
GetStringOption<CurrencyDisplay>(
isolate, options, "currencyDisplay", service,
{"code", "symbol", "name", "narrowSymbol"},
{CurrencyDisplay::CODE, CurrencyDisplay::SYMBOL,
CurrencyDisplay::NAME, CurrencyDisplay::NARROW_SYMBOL},
CurrencyDisplay::SYMBOL);
MAYBE_RETURN(maybe_currency_display, MaybeHandle<JSNumberFormat>());
CurrencyDisplay currency_display = maybe_currency_display.FromJust();
CurrencySign currency_sign = CurrencySign::STANDARD;
// 9. Let currencySign be ? GetOption(options, "currencySign", "string", «
// "standard", "accounting" », "standard").
Maybe<CurrencySign> maybe_currency_sign = GetStringOption<CurrencySign>(
isolate, options, "currencySign", service, {"standard", "accounting"},
{CurrencySign::STANDARD, CurrencySign::ACCOUNTING},
CurrencySign::STANDARD);
MAYBE_RETURN(maybe_currency_sign, MaybeHandle<JSNumberFormat>());
currency_sign = maybe_currency_sign.FromJust();
// 10. Let unit be ? GetOption(options, "unit", "string", undefined,
// undefined).
std::unique_ptr<char[]> unit_cstr;
Maybe<bool> found_unit = GetStringOption(isolate, options, "unit",
empty_values, service, &unit_cstr);
MAYBE_RETURN(found_unit, MaybeHandle<JSNumberFormat>());
std::pair<icu::MeasureUnit, icu::MeasureUnit> unit_pair;
// 11. If unit is not undefined, then
if (found_unit.FromJust()) {
DCHECK_NOT_NULL(unit_cstr.get());
std::string unit = unit_cstr.get();
// 11.a If the result of IsWellFormedUnitIdentifier(unit) is false, throw a
// RangeError exception.
Maybe<std::pair<icu::MeasureUnit, icu::MeasureUnit>> maybe_wellformed_unit =
IsWellFormedUnitIdentifier(isolate, unit);
if (maybe_wellformed_unit.IsNothing()) {
THROW_NEW_ERROR(
isolate,
NewRangeError(MessageTemplate::kInvalidUnit,
factory->NewStringFromAsciiChecked(service),
factory->NewStringFromAsciiChecked(unit.c_str())),
JSNumberFormat);
}
unit_pair = maybe_wellformed_unit.FromJust();
} else {
// 12. If style is "unit" and unit is undefined, throw a TypeError
// exception.
if (style == Style::UNIT) {
THROW_NEW_ERROR(isolate,
NewTypeError(MessageTemplate::kInvalidUnit,
factory->NewStringFromAsciiChecked(service),
factory->empty_string()),
JSNumberFormat);
}
}
// 13. Let unitDisplay be ? GetOption(options, "unitDisplay", "string", «
// "short", "narrow", "long" », "short").
Maybe<UnitDisplay> maybe_unit_display = GetStringOption<UnitDisplay>(
isolate, options, "unitDisplay", service, {"short", "narrow", "long"},
{UnitDisplay::SHORT, UnitDisplay::NARROW, UnitDisplay::LONG},
UnitDisplay::SHORT);
MAYBE_RETURN(maybe_unit_display, MaybeHandle<JSNumberFormat>());
UnitDisplay unit_display = maybe_unit_display.FromJust();
// 14. If style is "currency", then
icu::UnicodeString currency_ustr;
if (style == Style::CURRENCY) {
// 14.a. If currency is undefined, throw a TypeError exception.
if (!found_currency.FromJust()) {
THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kCurrencyCode),
JSNumberFormat);
}
// 14.a. Let currency be the result of converting currency to upper case as
// specified in 6.1
std::transform(currency.begin(), currency.end(), currency.begin(), toupper);
currency_ustr = currency.c_str();
// 14.b. Set numberFormat.[[Currency]] to currency.
if (!currency_ustr.isEmpty()) {
Handle<String> currency_string;
ASSIGN_RETURN_ON_EXCEPTION(isolate, currency_string,
Intl::ToString(isolate, currency_ustr),
JSNumberFormat);
settings =
settings.unit(icu::CurrencyUnit(currency_ustr.getBuffer(), status));
DCHECK(U_SUCCESS(status));
// 14.c Set intlObj.[[CurrencyDisplay]] to currencyDisplay.
// The default unitWidth is SHORT in ICU and that mapped from
// Symbol so we can skip the setting for optimization.
if (currency_display != CurrencyDisplay::SYMBOL) {
settings = settings.unitWidth(ToUNumberUnitWidth(currency_display));
}
DCHECK(U_SUCCESS(status));
}
}
// 15. If style is "unit", then
if (style == Style::UNIT) {
// Track newer style "unit".
isolate->CountUsage(v8::Isolate::UseCounterFeature::kNumberFormatStyleUnit);
icu::MeasureUnit none = icu::MeasureUnit();
// 13.b Set intlObj.[[Unit]] to unit.
if (unit_pair.first != AVOID_AMBIGUOUS_OP_WARNING(none)) {
settings = settings.unit(unit_pair.first);
}
if (unit_pair.second != AVOID_AMBIGUOUS_OP_WARNING(none)) {
settings = settings.perUnit(unit_pair.second);
}
// The default unitWidth is SHORT in ICU and that mapped from
// Symbol so we can skip the setting for optimization.
if (unit_display != UnitDisplay::SHORT) {
settings = settings.unitWidth(ToUNumberUnitWidth(unit_display));
}
}
// === End of SetNumberFormatUnitOptions
if (style == Style::PERCENT) {
settings = settings.unit(icu::MeasureUnit::getPercent())
.scale(icu::number::Scale::powerOfTen(2));
}
// 16. If style is "currency", then
int mnfd_default, mxfd_default;
if (style == Style::CURRENCY) {
// b. Let cDigits be CurrencyDigits(currency).
int c_digits = CurrencyDigits(currency_ustr);
// c. Let mnfdDefault be cDigits.
// d. Let mxfdDefault be cDigits.
mnfd_default = c_digits;
mxfd_default = c_digits;
// 17. Else,
} else {
// a. Let mnfdDefault be 0.
mnfd_default = 0;
// b. If style is "percent", then
if (style == Style::PERCENT) {
// i. Let mxfdDefault be 0.
mxfd_default = 0;
} else {
// c. Else,
// i. Let mxfdDefault be 3.
mxfd_default = 3;
}
}
Notation notation = Notation::STANDARD;
// 21. Let notation be ? GetOption(options, "notation", "string", «
// "standard", "scientific", "engineering", "compact" », "standard").
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, notation,
GetStringOption<Notation>(
isolate, options, "notation", service,
{"standard", "scientific", "engineering", "compact"},
{Notation::STANDARD, Notation::SCIENTIFIC, Notation::ENGINEERING,
Notation::COMPACT},
Notation::STANDARD),
Handle<JSNumberFormat>());
// 22. Set numberFormat.[[Notation]] to notation.
// 23. Perform ? SetNumberFormatDigitOptions(numberFormat, options,
// mnfdDefault, mxfdDefault).
Maybe<Intl::NumberFormatDigitOptions> maybe_digit_options =
Intl::SetNumberFormatDigitOptions(isolate, options, mnfd_default,
mxfd_default,
notation == Notation::COMPACT, service);
MAYBE_RETURN(maybe_digit_options, Handle<JSNumberFormat>());
Intl::NumberFormatDigitOptions digit_options = maybe_digit_options.FromJust();
// 13. If roundingIncrement is not 1, set mxfdDefault to mnfdDefault.
if (digit_options.rounding_increment != 1) {
mxfd_default = mnfd_default;
}
// 14. Set intlObj.[[RoundingIncrement]] to roundingIncrement.
// 15. Set intlObj.[[RoundingMode]] to roundingMode.
// 16. Set intlObj.[[TrailingZeroDisplay]] to trailingZeroDisplay.
settings = SetDigitOptionsToFormatter(settings, digit_options);
// 28. Let compactDisplay be ? GetOption(options, "compactDisplay",
// "string", « "short", "long" », "short").
Maybe<CompactDisplay> maybe_compact_display = GetStringOption<CompactDisplay>(
isolate, options, "compactDisplay", service, {"short", "long"},
{CompactDisplay::SHORT, CompactDisplay::LONG}, CompactDisplay::SHORT);
MAYBE_RETURN(maybe_compact_display, MaybeHandle<JSNumberFormat>());
CompactDisplay compact_display = maybe_compact_display.FromJust();
// The default notation in ICU is Simple, which mapped from STANDARD
// so we can skip setting it.
if (notation != Notation::STANDARD) {
settings = settings.notation(ToICUNotation(notation, compact_display));
}
// 28. Let defaultUseGrouping be "auto".
UseGrouping default_use_grouping = UseGrouping::AUTO;
// 29. If notation is "compact", then
if (notation == Notation::COMPACT) {
// a. Set numberFormat.[[CompactDisplay]] to compactDisplay.
// Done in above together
// b. Set defaultUseGrouping to "min2".
default_use_grouping = UseGrouping::MIN2;
}
// 30. Let useGrouping be ? GetStringOrBooleanOption(options, "useGrouping",
// « "min2", "auto", "always" », "always", false, defaultUseGrouping).
Maybe<UseGrouping> maybe_use_grouping = GetStringOrBooleanOption<UseGrouping>(
isolate, options, "useGrouping", service, {"min2", "auto", "always"},
{UseGrouping::MIN2, UseGrouping::AUTO, UseGrouping::ALWAYS},
UseGrouping::ALWAYS, // trueValue
UseGrouping::OFF, // falseValue
default_use_grouping); // fallbackValue
MAYBE_RETURN(maybe_use_grouping, MaybeHandle<JSNumberFormat>());
UseGrouping use_grouping = maybe_use_grouping.FromJust();
// 31. Set numberFormat.[[UseGrouping]] to useGrouping.
if (use_grouping != UseGrouping::AUTO) {
settings = settings.grouping(ToUNumberGroupingStrategy(use_grouping));
}
// 32. Let signDisplay be ? GetOption(options, "signDisplay", "string", «
// "auto", "never", "always", "exceptZero", "negative" », "auto").
Maybe<SignDisplay> maybe_sign_display = Nothing<SignDisplay>();
maybe_sign_display = GetStringOption<SignDisplay>(
isolate, options, "signDisplay", service,
{"auto", "never", "always", "exceptZero", "negative"},
{SignDisplay::AUTO, SignDisplay::NEVER, SignDisplay::ALWAYS,
SignDisplay::EXCEPT_ZERO, SignDisplay::NEGATIVE},
SignDisplay::AUTO);
MAYBE_RETURN(maybe_sign_display, MaybeHandle<JSNumberFormat>());
SignDisplay sign_display = maybe_sign_display.FromJust();
// 33. Set numberFormat.[[SignDisplay]] to signDisplay.
// The default sign in ICU is UNUM_SIGN_AUTO which is mapped from
// SignDisplay::AUTO and CurrencySign::STANDARD so we can skip setting
// under that values for optimization.
if (sign_display != SignDisplay::AUTO ||
currency_sign != CurrencySign::STANDARD) {
settings = settings.sign(ToUNumberSignDisplay(sign_display, currency_sign));
}
// 25. Let dataLocaleData be localeData.[[<dataLocale>]].
//
// 26. Let patterns be dataLocaleData.[[patterns]].
//
// 27. Assert: patterns is a record (see 11.3.3).
//
// 28. Let stylePatterns be patterns.[[<style>]].
//
// 29. Set numberFormat.[[PositivePattern]] to
// stylePatterns.[[positivePattern]].
//
// 30. Set numberFormat.[[NegativePattern]] to
// stylePatterns.[[negativePattern]].
//
icu::number::LocalizedNumberFormatter fmt = settings.locale(icu_locale);
Handle<Managed<icu::number::LocalizedNumberFormatter>>
managed_number_formatter =
Managed<icu::number::LocalizedNumberFormatter>::FromRawPtr(
isolate, 0, new icu::number::LocalizedNumberFormatter(fmt));
// Now all properties are ready, so we can allocate the result object.
Handle<JSNumberFormat> number_format = Handle<JSNumberFormat>::cast(
isolate->factory()->NewFastOrSlowJSObjectFromMap(map));
DisallowGarbageCollection no_gc;
number_format->set_locale(*locale_str);
number_format->set_icu_number_formatter(*managed_number_formatter);
number_format->set_bound_format(*factory->undefined_value());
// 31. Return numberFormat.
return number_format;
}
namespace {
icu::number::FormattedNumber FormatDecimalString(
Isolate* isolate,
const icu::number::LocalizedNumberFormatter& number_format,
Handle<String> string, UErrorCode& status) {
string = String::Flatten(isolate, string);
DisallowGarbageCollection no_gc;
const String::FlatContent& flat = string->GetFlatContent(no_gc);
int32_t length = string->length();
if (flat.IsOneByte()) {
const char* char_buffer =
reinterpret_cast<const char*>(flat.ToOneByteVector().begin());
return number_format.formatDecimal({char_buffer, length}, status);
}
return number_format.formatDecimal({string->ToCString().get(), length},
status);
}
} // namespace
bool IntlMathematicalValue::IsNaN() const { return i::IsNaN(*value_); }
MaybeHandle<String> IntlMathematicalValue::ToString(Isolate* isolate) const {
Handle<String> string;
if (IsNumber(*value_)) {
return isolate->factory()->NumberToString(value_);
}
if (IsBigInt(*value_)) {
return BigInt::ToString(isolate, Handle<BigInt>::cast(value_));
}
DCHECK(IsString(*value_));
return Handle<String>::cast(value_);
}
namespace {
Maybe<icu::number::FormattedNumber> IcuFormatNumber(
Isolate* isolate,
const icu::number::LocalizedNumberFormatter& number_format,
Handle<Object> numeric_obj) {
icu::number::FormattedNumber formatted;
// If it is BigInt, handle it differently.
UErrorCode status = U_ZERO_ERROR;
if (IsBigInt(*numeric_obj)) {
Handle<BigInt> big_int = Handle<BigInt>::cast(numeric_obj);
Handle<String> big_int_string;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, big_int_string,
BigInt::ToString(isolate, big_int),
Nothing<icu::number::FormattedNumber>());
big_int_string = String::Flatten(isolate, big_int_string);
DisallowGarbageCollection no_gc;
const String::FlatContent& flat = big_int_string->GetFlatContent(no_gc);
int32_t length = big_int_string->length();
DCHECK(flat.IsOneByte());
const char* char_buffer =
reinterpret_cast<const char*>(flat.ToOneByteVector().begin());
formatted = number_format.formatDecimal({char_buffer, length}, status);
} else {
if (IsString(*numeric_obj)) {
// TODO(ftang) Correct the handling of string after the resolution of
// https://github.com/tc39/proposal-intl-numberformat-v3/pull/82
Handle<String> string =
String::Flatten(isolate, Handle<String>::cast(numeric_obj));
DisallowGarbageCollection no_gc;
const String::FlatContent& flat = string->GetFlatContent(no_gc);
int32_t length = string->length();
if (flat.IsOneByte()) {
const char* char_buffer =
reinterpret_cast<const char*>(flat.ToOneByteVector().begin());
formatted = number_format.formatDecimal({char_buffer, length}, status);
} else {
// We may have two bytes string such as "漢 123456789".substring(2)
// The value will be "123456789" only in ASCII range, but encoded
// in two bytes string.
// ICU accepts UTF8 string, so if the source is two-byte encoded,
// copy into a UTF8 string via ToCString.
formatted = number_format.formatDecimal(
{string->ToCString().get(), string->length()}, status);
}
} else {
double number = IsNaN(*numeric_obj)
? std::numeric_limits<double>::quiet_NaN()
: Object::Number(*numeric_obj);
formatted = number_format.formatDouble(number, status);
}
}
if (U_FAILURE(status)) {
// This happen because of icu data trimming trim out "unit".
// See https://bugs.chromium.org/p/v8/issues/detail?id=8641
THROW_NEW_ERROR_RETURN_VALUE(isolate,
NewTypeError(MessageTemplate::kIcuError),
Nothing<icu::number::FormattedNumber>());
}
return Just(std::move(formatted));
}
} // namespace
Maybe<icu::number::FormattedNumber> IntlMathematicalValue::FormatNumeric(
Isolate* isolate,
const icu::number::LocalizedNumberFormatter& number_format,
const IntlMathematicalValue& x) {
if (IsString(*x.value_)) {
Handle<String> string;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, string, x.ToString(isolate),
Nothing<icu::number::FormattedNumber>());
UErrorCode status = U_ZERO_ERROR;
icu::number::FormattedNumber result =
FormatDecimalString(isolate, number_format, string, status);
if (U_FAILURE(status)) {
THROW_NEW_ERROR_RETURN_VALUE(isolate,
NewTypeError(MessageTemplate::kIcuError),
Nothing<icu::number::FormattedNumber>());
}
return Just(std::move(result));
}
CHECK(IsNumber(*x.value_) || IsBigInt(*x.value_));
return IcuFormatNumber(isolate, number_format, x.value_);
}
Maybe<icu::number::FormattedNumberRange> IntlMathematicalValue::FormatRange(
Isolate* isolate,
const icu::number::LocalizedNumberRangeFormatter& number_range_format,
const IntlMathematicalValue& x, const IntlMathematicalValue& y) {
icu::Formattable x_formatable;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, x_formatable, x.ToFormattable(isolate),
Nothing<icu::number::FormattedNumberRange>());
icu::Formattable y_formatable;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, y_formatable, y.ToFormattable(isolate),
Nothing<icu::number::FormattedNumberRange>());
UErrorCode status = U_ZERO_ERROR;
icu::number::FormattedNumberRange result =
number_range_format.formatFormattableRange(x_formatable, y_formatable,
status);
if (U_FAILURE(status)) {
THROW_NEW_ERROR_RETURN_VALUE(isolate,
NewTypeError(MessageTemplate::kIcuError),
Nothing<icu::number::FormattedNumberRange>());
}
return Just(std::move(result));
}
namespace {
// Return the index of the end of leading white space or line terminator
// and the index of the start of trailing white space or line terminator.
template <typename Char>
std::pair<int, int> FindLeadingAndTrailingWhiteSpaceOrLineTerminator(
base::Vector<const Char> src) {
size_t leading_end = 0;
// Find the length of leading StrWhiteSpaceChar.
while (leading_end < src.size() &&
IsWhiteSpaceOrLineTerminator(
static_cast<uint16_t>(src.at(leading_end)))) {
leading_end++;
}
size_t trailing_start = src.size();
// Find the start of the trailing StrWhiteSpaceChar
while (trailing_start > leading_end &&
IsWhiteSpaceOrLineTerminator(
static_cast<uint16_t>(src.at(trailing_start - 1)))) {
trailing_start--;
}
return std::make_pair(leading_end, trailing_start);
}
Handle<String> TrimWhiteSpaceOrLineTerminator(Isolate* isolate,
Handle<String> string) {
string = String::Flatten(isolate, string);
std::pair<int, int> whitespace_offsets;
{
DisallowGarbageCollection no_gc;
String::FlatContent flat = string->GetFlatContent(no_gc);
if (flat.IsOneByte()) {
whitespace_offsets = FindLeadingAndTrailingWhiteSpaceOrLineTerminator(
flat.ToOneByteVector());
} else {
whitespace_offsets =
FindLeadingAndTrailingWhiteSpaceOrLineTerminator(flat.ToUC16Vector());
}
}
if (whitespace_offsets.first == 0 &&
string->length() == whitespace_offsets.second) {
return string;
}
return isolate->factory()->NewSubString(string, whitespace_offsets.first,
whitespace_offsets.second);
}
} // namespace
// #sec-tointlmathematicalvalue
Maybe<IntlMathematicalValue> IntlMathematicalValue::From(Isolate* isolate,
Handle<Object> value) {
Factory* factory = isolate->factory();
// 1. Let primValue be ? ToPrimitive(value, number).
Handle<Object> prim_value;
if (IsJSReceiver(*value)) {
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, prim_value,
JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(value),
ToPrimitiveHint::kNumber),
Nothing<IntlMathematicalValue>());
} else {
prim_value = value;
}
IntlMathematicalValue result;
// 2. If Type(primValue) is BigInt, return the mathematical value of
// primValue.
if (IsBigInt(*prim_value)) {
result.value_ = prim_value;
result.approx_ = Handle<BigInt>::cast(prim_value)->AsInt64();
return Just(result);
}
if (IsOddball(*prim_value)) {
prim_value = Oddball::ToNumber(isolate, Handle<Oddball>::cast(prim_value));
}
if (IsNumber(*prim_value)) {
result.value_ = prim_value;
result.approx_ = Object::Number(*prim_value);
return Just(result);
}
if (!IsString(*prim_value)) {
// No need to convert from Number to String, just call ToNumber.
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, result.value_,
Object::ToNumber(isolate, prim_value),
Nothing<IntlMathematicalValue>());
result.approx_ = Object::Number(*result.value_);
return Just(result);
}
Handle<String> string = Handle<String>::cast(prim_value);
string = TrimWhiteSpaceOrLineTerminator(isolate, string);
if (string->length() == 0) {
result.value_ = handle(Smi::zero(), isolate);
result.approx_ = 0;
return Just(result);
}
// We may have a NonDecimalIntegerLiteral:
if (2 < string->length() && string->Get(0) == '0') {
uint16_t ch = string->Get(1);
if (ch == 'b' || ch == 'B' || ch == 'o' || ch == 'O' || ch == 'x' ||
ch == 'X') {
result.approx_ = StringToDouble(
isolate, string, ALLOW_HEX | ALLOW_OCTAL | ALLOW_BINARY, 0);
// If approx is within the precision, just return as Number.
if (result.approx_ < kMaxSafeInteger) {
result.value_ = isolate->factory()->NewNumber(result.approx_);
return Just(result);
}
// Otherwise return the BigInt
MaybeHandle<BigInt> maybe_bigint = StringToBigInt(isolate, string);
// If the parsing of BigInt fail, return nan
if (maybe_bigint.is_null()) {
isolate->clear_pending_exception();
result.value_ = factory->nan_value();
return Just(result);
}
result.value_ = maybe_bigint.ToHandleChecked();
return Just(result);
}
}
// If it does not fit StrDecimalLiteral StrWhiteSpace_opt, StringToDouble will
// parse it as NaN, in that case, return NaN.
result.approx_ = StringToDouble(isolate, string, NO_CONVERSION_FLAGS, 0);
if (std::isnan(result.approx_)) {
result.value_ = factory->nan_value();
return Just(result);
}
// Handle Infinity / +Infinity / -Infinity
if (!std::isfinite(result.approx_)) {
if (result.approx_ < 0) {
result.value_ = factory->minus_infinity_value();
} else {
result.value_ = factory->infinity_value();
}
return Just(result);
}
// At this point, str is for sure fit
// "StrNumericLiteral StrWhiteSpace_opt" excluding "(+|-)?Infinity"
result.value_ = string;
return Just(result);
}
Maybe<icu::Formattable> IntlMathematicalValue::ToFormattable(
Isolate* isolate) const {
if (IsNumber(*value_)) {
return Just(icu::Formattable(approx_));
}
Handle<String> string;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, string, ToString(isolate),
Nothing<icu::Formattable>());
UErrorCode status = U_ZERO_ERROR;
{
DisallowGarbageCollection no_gc;
const String::FlatContent& flat = string->GetFlatContent(no_gc);
int length = string->length();
if (flat.IsOneByte()) {
icu::Formattable result(
{reinterpret_cast<const char*>(flat.ToOneByteVector().begin()),
length},
status);
if (U_SUCCESS(status)) return Just(result);
} else {
icu::Formattable result({string->ToCString().get(), length}, status);
if (U_SUCCESS(status)) return Just(result);
}
}
THROW_NEW_ERROR_RETURN_VALUE(isolate,
NewTypeError(MessageTemplate::kIcuError),
Nothing<icu::Formattable>());
}
namespace {
bool cmp_NumberFormatSpan(const NumberFormatSpan& a,
const NumberFormatSpan& b) {
// Regions that start earlier should be encountered earlier.
if (a.begin_pos < b.begin_pos) return true;
if (a.begin_pos > b.begin_pos) return false;
// For regions that start in the same place, regions that last longer should
// be encountered earlier.
if (a.end_pos < b.end_pos) return false;
if (a.end_pos > b.end_pos) return true;
// For regions that are exactly the same, one of them must be the "literal"
// backdrop we added, which has a field_id of -1, so consider higher field_ids
// to be later.
return a.field_id < b.field_id;
}
} // namespace
// Flattens a list of possibly-overlapping "regions" to a list of
// non-overlapping "parts". At least one of the input regions must span the
// entire space of possible indexes. The regions parameter will sorted in-place
// according to some criteria; this is done for performance to avoid copying the
// input.
std::vector<NumberFormatSpan> FlattenRegionsToParts(
std::vector<NumberFormatSpan>* regions) {
// The intention of this algorithm is that it's used to translate ICU "fields"
// to JavaScript "parts" of a formatted string. Each ICU field and JavaScript
// part has an integer field_id, which corresponds to something like "grouping
// separator", "fraction", or "percent sign", and has a begin and end
// position. Here's a diagram of:
// var nf = new Intl.NumberFormat(['de'], {style:'currency',currency:'EUR'});
// nf.formatToParts(123456.78);
// : 6
// input regions: 0000000211 7
// ('-' means -1): ------------
// formatted string: "123.456,78 €"
// output parts: 0006000211-7
// To illustrate the requirements of this algorithm, here's a contrived and
// convoluted example of inputs and expected outputs:
// : 4
// : 22 33 3
// : 11111 22
// input regions: 0000000 111
// : ------------
// formatted string: "abcdefghijkl"
// output parts: 0221340--231
// (The characters in the formatted string are irrelevant to this function.)
// We arrange the overlapping input regions like a mountain range where
// smaller regions are "on top" of larger regions, and we output a birds-eye
// view of the mountains, so that smaller regions take priority over larger
// regions.
std::sort(regions->begin(), regions->end(), cmp_NumberFormatSpan);
std::vector<size_t> overlapping_region_index_stack;
// At least one item in regions must be a region spanning the entire string.
// Due to the sorting above, the first item in the vector will be one of them.
overlapping_region_index_stack.push_back(0);
NumberFormatSpan top_region = regions->at(0);
size_t region_iterator = 1;
int32_t entire_size = top_region.end_pos;
std::vector<NumberFormatSpan> out_parts;
// The "climber" is a cursor that advances from left to right climbing "up"
// and "down" the mountains. Whenever the climber moves to the right, that
// represents an item of output.
int32_t climber = 0;
while (climber < entire_size) {
int32_t next_region_begin_pos;
if (region_iterator < regions->size()) {
next_region_begin_pos = regions->at(region_iterator).begin_pos;
} else {
// finish off the rest of the input by proceeding to the end.
next_region_begin_pos = entire_size;
}
if (climber < next_region_begin_pos) {
while (top_region.end_pos < next_region_begin_pos) {
if (climber < top_region.end_pos) {
// step down
out_parts.push_back(NumberFormatSpan(top_region.field_id, climber,
top_region.end_pos));
climber = top_region.end_pos;
} else {
// drop down
}
overlapping_region_index_stack.pop_back();
top_region = regions->at(overlapping_region_index_stack.back());
}
if (climber < next_region_begin_pos) {
// cross a plateau/mesa/valley
out_parts.push_back(NumberFormatSpan(top_region.field_id, climber,
next_region_begin_pos));
climber = next_region_begin_pos;
}
}
if (region_iterator < regions->size()) {
overlapping_region_index_stack.push_back(region_iterator++);
top_region = regions->at(overlapping_region_index_stack.back());
}
}
return out_parts;
}
namespace {
Maybe<int> ConstructParts(Isolate* isolate,
const icu::FormattedValue& formatted,
Handle<JSArray> result, int start_index,
bool style_is_unit, bool is_nan, bool output_source,
bool output_unit, Handle<String> unit) {
UErrorCode status = U_ZERO_ERROR;
icu::UnicodeString formatted_text = formatted.toString(status);
if (U_FAILURE(status)) {
THROW_NEW_ERROR_RETURN_VALUE(
isolate, NewTypeError(MessageTemplate::kIcuError), Nothing<int>());
}
int32_t length = formatted_text.length();
int index = start_index;
if (length == 0) return Just(index);
std::vector<NumberFormatSpan> regions;
// Add a "literal" backdrop for the entire string. This will be used if no
// other region covers some part of the formatted string. It's possible
// there's another field with exactly the same begin and end as this backdrop,
// in which case the backdrop's field_id of -1 will give it lower priority.
regions.push_back(NumberFormatSpan(-1, 0, formatted_text.length()));
Intl::FormatRangeSourceTracker tracker;
{
icu::ConstrainedFieldPosition cfpos;
while (formatted.nextPosition(cfpos, 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_RANGE_SPAN) {
DCHECK_LE(field, 2);
tracker.Add(field, start, limit);
} else {
regions.push_back(NumberFormatSpan(field, start, limit));
}
}
}
std::vector<NumberFormatSpan> parts = FlattenRegionsToParts(®ions);
for (auto it = parts.begin(); it < parts.end(); it++) {
NumberFormatSpan part = *it;
Handle<String> field_type_string = isolate->factory()->literal_string();
if (part.field_id != -1) {
if (style_is_unit && static_cast<UNumberFormatFields>(part.field_id) ==
UNUM_PERCENT_FIELD) {
// Special case when style is unit.
field_type_string = isolate->factory()->unit_string();
} else {
field_type_string =
Intl::NumberFieldToType(isolate, part, formatted_text, is_nan);
}
}
Handle<String> substring;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, substring,
Intl::ToString(isolate, formatted_text, part.begin_pos, part.end_pos),
Nothing<int>());
if (output_source) {
Intl::AddElement(
isolate, result, index, field_type_string, substring,
isolate->factory()->source_string(),
Intl::SourceString(isolate,
tracker.GetSource(part.begin_pos, part.end_pos)));
} else {
if (output_unit) {
Intl::AddElement(isolate, result, index, field_type_string, substring,
isolate->factory()->unit_string(), unit);
} else {
Intl::AddElement(isolate, result, index, field_type_string, substring);
}
}
++index;
}
JSObject::ValidateElements(*result);
return Just(index);
}
} // namespace
Maybe<int> Intl::AddNumberElements(Isolate* isolate,
const icu::FormattedValue& formatted,
Handle<JSArray> result, int start_index,
Handle<String> unit) {
return ConstructParts(isolate, formatted, result, start_index, true, false,
false, true, unit);
}
namespace {
// #sec-partitionnumberrangepattern
template <typename T, MaybeHandle<T> (*F)(
Isolate*, const icu::FormattedValue&,
const icu::number::LocalizedNumberFormatter&, bool)>
MaybeHandle<T> PartitionNumberRangePattern(Isolate* isolate,
Handle<JSNumberFormat> number_format,
Handle<Object> start,
Handle<Object> end,
const char* func_name) {
Factory* factory = isolate->factory();
// 4. Let x be ? ToIntlMathematicalValue(start).
IntlMathematicalValue x;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, x, IntlMathematicalValue::From(isolate, start), Handle<T>());
// 5. Let y be ? ToIntlMathematicalValue(end).
IntlMathematicalValue y;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, y, IntlMathematicalValue::From(isolate, end), Handle<T>());
// 1. If x is not-a-number or y is not-a-number, throw a RangeError exception.
if (x.IsNaN()) {
THROW_NEW_ERROR_RETURN_VALUE(
isolate,
NewRangeError(MessageTemplate::kInvalid,
factory->NewStringFromStaticChars("start"), start),
MaybeHandle<T>());
}
if (y.IsNaN()) {
THROW_NEW_ERROR_RETURN_VALUE(
isolate,
NewRangeError(MessageTemplate::kInvalid,
factory->NewStringFromStaticChars("end"), end),
MaybeHandle<T>());
}
Maybe<icu::number::LocalizedNumberRangeFormatter> maybe_range_formatter =
JSNumberFormat::GetRangeFormatter(
isolate, number_format->locale(),
*number_format->icu_number_formatter()->raw());
MAYBE_RETURN(maybe_range_formatter, MaybeHandle<T>());
icu::number::LocalizedNumberRangeFormatter nrfmt =
maybe_range_formatter.FromJust();
Maybe<icu::number::FormattedNumberRange> maybe_formatted =
IntlMathematicalValue::FormatRange(isolate, nrfmt, x, y);
MAYBE_RETURN(maybe_formatted, Handle<T>());
icu::number::FormattedNumberRange formatted =
std::move(maybe_formatted).FromJust();
return F(isolate, formatted, *(number_format->icu_number_formatter()->raw()),
false /* is_nan */);
}
MaybeHandle<String> FormatToString(Isolate* isolate,
const icu::FormattedValue& formatted,
const icu::number::LocalizedNumberFormatter&,
bool) {
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);
}
MaybeHandle<JSArray> FormatToJSArray(
Isolate* isolate, const icu::FormattedValue& formatted,
const icu::number::LocalizedNumberFormatter& nfmt, bool is_nan,
bool output_source) {
UErrorCode status = U_ZERO_ERROR;
bool is_unit = Style::UNIT == StyleFromSkeleton(nfmt.toSkeleton(status));
CHECK(U_SUCCESS(status));
Factory* factory = isolate->factory();
Handle<JSArray> result = factory->NewJSArray(0);
int format_to_parts;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, format_to_parts,
ConstructParts(isolate, formatted, result, 0, is_unit, is_nan,
output_source, false, Handle<String>()),
Handle<JSArray>());
USE(format_to_parts);
return result;
}
MaybeHandle<JSArray> FormatRangeToJSArray(
Isolate* isolate, const icu::FormattedValue& formatted,
const icu::number::LocalizedNumberFormatter& nfmt, bool is_nan) {
return FormatToJSArray(isolate, formatted, nfmt, is_nan, true);
}
} // namespace
Maybe<icu::number::LocalizedNumberRangeFormatter>
JSNumberFormat::GetRangeFormatter(
Isolate* isolate, Tagged<String> locale,
const icu::number::LocalizedNumberFormatter& number_formatter) {
UErrorCode status = U_ZERO_ERROR;
UParseError perror;
icu::number::LocalizedNumberRangeFormatter range_formatter =
icu::number::UnlocalizedNumberRangeFormatter()
.numberFormatterBoth(icu::number::NumberFormatter::forSkeleton(
number_formatter.toSkeleton(status), perror, status))
.locale(
icu::Locale::forLanguageTag(locale->ToCString().get(), status));
if (U_FAILURE(status)) {
THROW_NEW_ERROR_RETURN_VALUE(
isolate, NewTypeError(MessageTemplate::kIcuError),
Nothing<icu::number::LocalizedNumberRangeFormatter>());
}
return Just(range_formatter);
}
MaybeHandle<String> JSNumberFormat::FormatNumeric(
Isolate* isolate,
const icu::number::LocalizedNumberFormatter& number_format,
Handle<Object> numeric_obj) {
Maybe<icu::number::FormattedNumber> maybe_format =
IcuFormatNumber(isolate, number_format, numeric_obj);
MAYBE_RETURN(maybe_format, Handle<String>());
icu::number::FormattedNumber formatted = std::move(maybe_format).FromJust();
return FormatToString(isolate, formatted, number_format, IsNaN(*numeric_obj));
}
MaybeHandle<String> JSNumberFormat::NumberFormatFunction(
Isolate* isolate, Handle<JSNumberFormat> number_format,
Handle<Object> value) {
icu::number::LocalizedNumberFormatter* fmt =
number_format->icu_number_formatter()->raw();
CHECK_NOT_NULL(fmt);
// 4. Let x be ? ToIntlMathematicalValue(value).
IntlMathematicalValue x;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, x, IntlMathematicalValue::From(isolate, value),
Handle<String>());
// 5. Return FormatNumeric(nf, x).
Maybe<icu::number::FormattedNumber> maybe_formatted =
IntlMathematicalValue::FormatNumeric(isolate, *fmt, x);
MAYBE_RETURN(maybe_formatted, Handle<String>());
icu::number::FormattedNumber formatted =
std::move(maybe_formatted).FromJust();
return FormatToString(isolate, formatted, *fmt, x.IsNaN());
}
MaybeHandle<JSArray> JSNumberFormat::FormatToParts(
Isolate* isolate, Handle<JSNumberFormat> number_format,
Handle<Object> numeric_obj) {
icu::number::LocalizedNumberFormatter* fmt =
number_format->icu_number_formatter()->raw();
DCHECK_NOT_NULL(fmt);
IntlMathematicalValue value;
MAYBE_ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, value, IntlMathematicalValue::From(isolate, numeric_obj),
Handle<JSArray>());
Maybe<icu::number::FormattedNumber> maybe_formatted =
IntlMathematicalValue::FormatNumeric(isolate, *fmt, value);
MAYBE_RETURN(maybe_formatted, Handle<JSArray>());
icu::number::FormattedNumber formatted =
std::move(maybe_formatted).FromJust();
return FormatToJSArray(isolate, formatted, *fmt, value.IsNaN(), false);
}
// #sec-number-format-functions
MaybeHandle<String> JSNumberFormat::FormatNumericRange(
Isolate* isolate, Handle<JSNumberFormat> number_format,
Handle<Object> x_obj, Handle<Object> y_obj) {
return PartitionNumberRangePattern<String, FormatToString>(
isolate, number_format, x_obj, y_obj,
"Intl.NumberFormat.prototype.formatRange");
}
MaybeHandle<JSArray> JSNumberFormat::FormatNumericRangeToParts(
Isolate* isolate, Handle<JSNumberFormat> number_format,
Handle<Object> x_obj, Handle<Object> y_obj) {
return PartitionNumberRangePattern<JSArray, FormatRangeToJSArray>(
isolate, number_format, x_obj, y_obj,
"Intl.NumberFormat.prototype.formatRangeToParts");
}
namespace {
struct CheckNumberElements {
static const char* key() { return "NumberElements"; }
static const char* path() { return nullptr; }
};
} // namespace
const std::set<std::string>& JSNumberFormat::GetAvailableLocales() {
static base::LazyInstance<Intl::AvailableLocales<CheckNumberElements>>::type
available_locales = LAZY_INSTANCE_INITIALIZER;
return available_locales.Pointer()->Get();
}
} // namespace internal
} // namespace v8
Zerion Mini Shell 1.0