WTF_MAKE_NONCOPYABLE(SpecialValueHandler);

enum HandleResult {

BothFinite,

BothInfinity,

EitherNaN,

LHSIsInfinity,

RHSIsInfinity,

};

SpecialValueHandler(const Decimal& lhs, const Decimal& rhs);

HandleResult handle();

Decimal value() const;

enum Result {

ResultIsLHS,

ResultIsRHS,

ResultIsUnknown,

};

const Decimal& m_lhs;

const Decimal& m_rhs;

Result m_result;

{

if (m_lhs.isFinite() && m_rhs.isFinite())

return BothFinite;

const Decimal::EncodedData::FormatClass lhsClass = m_lhs.value().formatClass();

const Decimal::EncodedData::FormatClass rhsClass = m_rhs.value().formatClass();

if (lhsClass == Decimal::EncodedData::ClassNaN) {

m_result = ResultIsLHS;

return EitherNaN;

}

if (rhsClass == Decimal::EncodedData::ClassNaN) {

m_result = ResultIsRHS;

return EitherNaN;

}

if (lhsClass == Decimal::EncodedData::ClassInfinity)

return rhsClass == Decimal::EncodedData::ClassInfinity ? BothInfinity : LHSIsInfinity;

if (rhsClass == Decimal::EncodedData::ClassInfinity)

return RHSIsInfinity;

ASSERT_NOT_REACHED();

return BothFinite;

{

switch (m_result) {

case ResultIsLHS:

return m_lhs;

case ResultIsRHS:

return m_rhs;

case ResultIsUnknown:

default:

ASSERT_NOT_REACHED();

return m_lhs;

}

UInt128(uint64_t low, uint64_t high)

: m_high(high), m_low(low)

{

}

UInt128& operator/=(uint32_t);

uint64_t high() const { return m_high; }

uint64_t low() const { return m_low; }

static UInt128 multiply(uint64_t u, uint64_t v) { return UInt128(u * v, multiplyHigh(u, v)); }

static uint32_t highUInt32(uint64_t x) { return static_cast<uint32_t>(x >> 32); }

static uint32_t lowUInt32(uint64_t x) { return static_cast<uint32_t>(x & ((static_cast<uint64_t>(1) << 32) - 1)); }

bool isZero() const { return !m_low && !m_high; }

static uint64_t makeUInt64(uint32_t low, uint32_t high) { return low | (static_cast<uint64_t>(high) << 32); }

static uint64_t multiplyHigh(uint64_t, uint64_t);

uint64_t m_high;

uint64_t m_low;

{

const uint64_t uLow = lowUInt32(u);

const uint64_t uHigh = highUInt32(u);

const uint64_t vLow = lowUInt32(v);

const uint64_t vHigh = highUInt32(v);

const uint64_t partialProduct = uHigh * vLow + highUInt32(uLow * vLow);

return uHigh * vHigh + highUInt32(partialProduct) + highUInt32(uLow * vHigh + lowUInt32(partialProduct));

{

int numberOfDigits = 0;

for (uint64_t powerOfTen = 1; x >= powerOfTen; powerOfTen *= 10) {

++numberOfDigits;

if (powerOfTen >= std::numeric_limits<uint64_t>::max() / 10)

break;

}

return numberOfDigits;

{

ASSERT(n >= 0);

while (n > 0 && x) {

x /= 10;

--n;

}

return x;

{

ASSERT(n >= 0);

ASSERT(n < Precision);

uint64_t y = 1;

uint64_t z = 10;

for (;;) {

if (n & 1)

y = y * z;

n >>= 1;

if (!n)

return x * y;

z = z * z;

}

{

Decimal result(*this);

result.m_data.setSign(Positive);

return result;

{

ASSERT(lhs.isFinite());

ASSERT(rhs.isFinite());

const int lhsExponent = lhs.exponent();

const int rhsExponent = rhs.exponent();

int exponent = std::min(lhsExponent, rhsExponent);

uint64_t lhsCoefficient = lhs.m_data.coefficient();

uint64_t rhsCoefficient = rhs.m_data.coefficient();

if (lhsExponent > rhsExponent) {

const int numberOfLHSDigits = countDigits(lhsCoefficient);

if (numberOfLHSDigits) {

const int lhsShiftAmount = lhsExponent - rhsExponent;

const int overflow = numberOfLHSDigits + lhsShiftAmount - Precision;

if (overflow <= 0)

lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount);

else {

lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount - overflow);

rhsCoefficient = scaleDown(rhsCoefficient, overflow);

exponent += overflow;

}

}

} else if (lhsExponent < rhsExponent) {

const int numberOfRHSDigits = countDigits(rhsCoefficient);

if (numberOfRHSDigits) {

const int rhsShiftAmount = rhsExponent - lhsExponent;

const int overflow = numberOfRHSDigits + rhsShiftAmount - Precision;

if (overflow <= 0)

rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount);

else {

rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount - overflow);

lhsCoefficient = scaleDown(lhsCoefficient, overflow);

exponent += overflow;

}

}

}

AlignedOperands alignedOperands;

alignedOperands.exponent = exponent;

alignedOperands.lhsCoefficient = lhsCoefficient;

alignedOperands.rhsCoefficient = rhsCoefficient;

return alignedOperands;

{

if (isSpecial())

return *this;

if (exponent() >= 0)

return *this;

uint64_t result = m_data.coefficient();

const int numberOfDigits = countDigits(result);

const int numberOfDropDigits = -exponent();

if (numberOfDigits < numberOfDropDigits)

return isPositive() ? Decimal(1) : zero(Positive);

result = scaleDown(result, numberOfDropDigits - 1);

if (sign() == Positive && result % 10 > 0)

result += 10;

result /= 10;

return Decimal(sign(), 0, result);

{

const Decimal result(*this - rhs);

switch (result.m_data.formatClass()) {

case EncodedData::ClassInfinity:

return result.isNegative() ? Decimal(-1) : Decimal(1);

case EncodedData::ClassNaN:

case EncodedData::ClassNormal:

return result;

case EncodedData::ClassZero:

return zero(Positive);

default:

ASSERT_NOT_REACHED();

return nan();

}

{

if (isSpecial())

return *this;

if (exponent() >= 0)

return *this;

uint64_t result = m_data.coefficient();

const int numberOfDigits = countDigits(result);

const int numberOfDropDigits = -exponent();

if (numberOfDigits < numberOfDropDigits)

return isPositive() ? zero(Positive) : Decimal(-1);

result = scaleDown(result, numberOfDropDigits - 1);

if (isNegative() && result % 10 > 0)

result += 10;

result /= 10;

return Decimal(sign(), 0, result);

{

if (std::isfinite(doubleValue)) {

// FIXME: Change fromString to take a StringView instead of a String and then

// use a fixed size stack buffer instead of allocating and deallocating a string.

return fromString(String::number(doubleValue));

}

if (std::isinf(doubleValue))

return infinity(doubleValue < 0 ? Negative : Positive);

return nan();

{

int exponent = 0;

Sign exponentSign = Positive;

int numberOfDigits = 0;

int numberOfDigitsAfterDot = 0;

int numberOfExtraDigits = 0;

Sign sign = Positive;

enum {

StateDigit,

StateDot,

StateDotDigit,

StateE,

StateEDigit,

StateESign,

StateSign,

StateStart,

StateZero,

} state = StateStart;

#define HandleCharAndBreak(expected, nextState) \

if (ch == expected) { \

state = nextState; \

break; \

}

#define HandleTwoCharsAndBreak(expected1, expected2, nextState) \

if (ch == expected1 || ch == expected2) { \

state = nextState; \

break; \

}

uint64_t accumulator = 0;

for (unsigned index = 0; index < str.length(); ++index) {

const int ch = str[index];

switch (state) {

case StateDigit:

if (isASCIIDigit(ch)) {

if (numberOfDigits < Precision) {

++numberOfDigits;

accumulator *= 10;

accumulator += ch - '0';

} else

++numberOfExtraDigits;

break;

}

HandleCharAndBreak('.', StateDot);

HandleTwoCharsAndBreak('E', 'e', StateE);

return nan();

case StateDot:

if (isASCIIDigit(ch)) {

if (numberOfDigits < Precision) {

++numberOfDigits;

++numberOfDigitsAfterDot;

accumulator *= 10;

accumulator += ch - '0';

}

state = StateDotDigit;

break;

}

// FIXME: <http://webkit.org/b/127667> Decimal::fromString's EBNF documentation does not match implementation

FALLTHROUGH;

case StateDotDigit:

if (isASCIIDigit(ch)) {

if (numberOfDigits < Precision) {

++numberOfDigits;

++numberOfDigitsAfterDot;

accumulator *= 10;

accumulator += ch - '0';

}

break;

}

HandleTwoCharsAndBreak('E', 'e', StateE);

return nan();

case StateE:

if (ch == '+') {

exponentSign = Positive;

state = StateESign;

break;

}

if (ch == '-') {

exponentSign = Negative;

state = StateESign;

break;

}

if (isASCIIDigit(ch)) {

exponent = ch - '0';

state = StateEDigit;

break;

}

return nan();

case StateEDigit:

if (isASCIIDigit(ch)) {

exponent *= 10;

exponent += ch - '0';

if (exponent > ExponentMax + Precision) {

if (accumulator)

return exponentSign == Negative ? zero(Positive) : infinity(sign);

return zero(sign);

}

state = StateEDigit;

break;

}

return nan();

case StateESign:

if (isASCIIDigit(ch)) {

exponent = ch - '0';

state = StateEDigit;

break;

}

return nan();

case StateSign:

if (ch >= '1' && ch <= '9') {

accumulator = ch - '0';

numberOfDigits = 1;

state = StateDigit;

break;

}

HandleCharAndBreak('0', StateZero);

HandleCharAndBreak('.', StateDot);

return nan();

case StateStart:

if (ch >= '1' && ch <= '9') {

accumulator = ch - '0';

numberOfDigits = 1;

state = StateDigit;

break;

}

if (ch == '-') {

sign = Negative;

state = StateSign;

break;

}

if (ch == '+') {

sign = Positive;

state = StateSign;

break;

}

HandleCharAndBreak('0', StateZero);

HandleCharAndBreak('.', StateDot);

return nan();

case StateZero:

if (ch == '0')

break;

if (ch >= '1' && ch <= '9') {

accumulator = ch - '0';

numberOfDigits = 1;

state = StateDigit;

break;

}

HandleCharAndBreak('.', StateDot);

HandleTwoCharsAndBreak('E', 'e', StateE);

return nan();

default:

ASSERT_NOT_REACHED();

return nan();

}

}

if (state == StateZero)

return zero(sign);

if (state == StateDigit || state == StateDot || state == StateDotDigit || state == StateEDigit) {

int resultExponent = exponent * (exponentSign == Negative ? -1 : 1) - numberOfDigitsAfterDot + numberOfExtraDigits;

if (resultExponent < ExponentMin)

return zero(Positive);

const int overflow = resultExponent - ExponentMax + 1;

if (overflow > 0) {

if (overflow + numberOfDigits - numberOfDigitsAfterDot > Precision)

return infinity(sign);

accumulator = scaleUp(accumulator, overflow);

resultExponent -= overflow;

}

return Decimal(sign, resultExponent, accumulator);

}

return nan();

{

const Decimal quotient = *this / rhs;

return quotient.isSpecial() ? quotient : *this - (quotient.isNegative() ? quotient.ceiling() : quotient.floor()) * rhs;

{

if (isSpecial())

return *this;

if (exponent() >= 0)

return *this;

uint64_t result = m_data.coefficient();

const int numberOfDigits = countDigits(result);

const int numberOfDropDigits = -exponent();

if (numberOfDigits < numberOfDropDigits)

return zero(Positive);

result = scaleDown(result, numberOfDropDigits - 1);

if (result % 10 >= 5)

result += 10;

result /= 10;

return Decimal(sign(), 0, result);

{

if (isFinite()) {

bool valid;

const double doubleValue = toString().toDouble(&valid);

return valid ? doubleValue : std::numeric_limits<double>::quiet_NaN();

}

if (isInfinity())

return isNegative() ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity();

return std::numeric_limits<double>::quiet_NaN();

{

switch (m_data.formatClass()) {

case EncodedData::ClassInfinity:

return sign() ? "-Infinity"_s : "Infinity"_s;

case EncodedData::ClassNaN:

return "NaN"_s;

case EncodedData::ClassNormal:

case EncodedData::ClassZero:

break;

default:

ASSERT_NOT_REACHED();

return emptyString();

}

StringBuilder builder;

if (sign())

builder.append('-');

int originalExponent = exponent();

uint64_t coefficient = m_data.coefficient();

if (originalExponent < 0) {

const int maxDigits = DBL_DIG;

uint64_t lastDigit = 0;

while (countDigits(coefficient) > maxDigits) {

lastDigit = coefficient % 10;

coefficient /= 10;

++originalExponent;

}

if (lastDigit >= 5)

++coefficient;

while (originalExponent < 0 && coefficient && !(coefficient % 10)) {

coefficient /= 10;

++originalExponent;

}

}

const String digits = String::number(coefficient);

int coefficientLength = static_cast<int>(digits.length());

const int adjustedExponent = originalExponent + coefficientLength - 1;

if (originalExponent <= 0 && adjustedExponent >= -6) {

if (!originalExponent) {

builder.append(digits);

return builder.toString();