The Tor Browser / file revision

 /*

  * Copyright (C) 2012 Google Inc. All rights reserved.

  *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions are

  * met:

  *

  *     * Redistributions of source code must retain the above copyright

  * notice, this list of conditions and the following disclaimer.

  *     * Redistributions in binary form must reproduce the above

  * copyright notice, this list of conditions and the following disclaimer

  * in the documentation and/or other materials provided with the

  * distribution.

  *     * Neither the name of Google Inc. nor the names of its

  * contributors may be used to endorse or promote products derived from

  * this software without specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  */

 #include "Decimal.h"

 #include "moz-decimal-utils.h"

 #include <algorithm>

 #include <float.h>

 using namespace moz_decimal_utils;

 namespace WebCore {

 namespace DecimalPrivate {

 static int const ExponentMax = 1023;

 static int const ExponentMin = -1023;

 static int const Precision = 18;

 static const uint64_t MaxCoefficient = UINT64_C(0x16345785D89FFFF); // 999999999999999999 == 18 9's

 // This class handles Decimal special values.

 class SpecialValueHandler {

     WTF_MAKE_NONCOPYABLE(SpecialValueHandler);

 public:

     enum HandleResult {

         BothFinite,

         BothInfinity,

         EitherNaN,

         LHSIsInfinity,

         RHSIsInfinity,

     };

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

     HandleResult handle();

     Decimal value() const;

 private:

     enum Result {

         ResultIsLHS,

         ResultIsRHS,

         ResultIsUnknown,

     };

     const Decimal& m_lhs;

     const Decimal& m_rhs;

     Result m_result;

 };

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

     : m_lhs(lhs), m_rhs(rhs), m_result(ResultIsUnknown)

 {

 }

 SpecialValueHandler::HandleResult SpecialValueHandler::handle()

 {

     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;

 }

 Decimal SpecialValueHandler::value() const

 {

     switch (m_result) {

     case ResultIsLHS:

         return m_lhs;

     case ResultIsRHS:

         return m_rhs;

     case ResultIsUnknown:

     default:

         ASSERT_NOT_REACHED();

         return m_lhs;

     }

 }

 // This class is used for 128 bit unsigned integer arithmetic.

 class UInt128 {

 public:

     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)); }

 private:

     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;

 };

 UInt128& UInt128::operator/=(const uint32_t divisor)

 {

     ASSERT(divisor);

     if (!m_high) {

         m_low /= divisor;

         return *this;

     }

     uint32_t dividend[4];

     dividend[0] = lowUInt32(m_low);

     dividend[1] = highUInt32(m_low);

     dividend[2] = lowUInt32(m_high);

     dividend[3] = highUInt32(m_high);

     uint32_t quotient[4];

     uint32_t remainder = 0;

     for (int i = 3; i >= 0; --i) {

         const uint64_t work = makeUInt64(dividend[i], remainder);

         remainder = static_cast<uint32_t>(work % divisor);

         quotient[i] = static_cast<uint32_t>(work / divisor);

     }

     m_low = makeUInt64(quotient[0], quotient[1]);

     m_high = makeUInt64(quotient[2], quotient[3]);

     return *this;

 }

 // Returns high 64bit of 128bit product.

 uint64_t UInt128::multiplyHigh(uint64_t u, uint64_t v)

 {

     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));

 }

 static int countDigits(uint64_t x)

 {

     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;

 }

 static uint64_t scaleDown(uint64_t x, int n)

 {

     ASSERT(n >= 0);

     while (n > 0 && x) {

         x /= 10;

         --n;

     }

     return x;

 }

 static uint64_t scaleUp(uint64_t x, int n)

 {

     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;

     }

 }

 } // namespace DecimalPrivate

 using namespace DecimalPrivate;

 Decimal::EncodedData::EncodedData(Sign sign, FormatClass formatClass)

     : m_coefficient(0)

     , m_exponent(0)

     , m_formatClass(formatClass)

     , m_sign(sign)

 {

 }

 Decimal::EncodedData::EncodedData(Sign sign, int exponent, uint64_t coefficient)

     : m_formatClass(coefficient ? ClassNormal : ClassZero)

     , m_sign(sign)

 {

     if (exponent >= ExponentMin && exponent <= ExponentMax) {

         while (coefficient > MaxCoefficient) {

             coefficient /= 10;

             ++exponent;

         }

     }

     if (exponent > ExponentMax) {

         m_coefficient = 0;

         m_exponent = 0;

         m_formatClass = ClassInfinity;

         return;

     }

     if (exponent < ExponentMin) {

         m_coefficient = 0;

         m_exponent = 0;

         m_formatClass = ClassZero;

         return;

     }

     m_coefficient = coefficient;

     m_exponent = static_cast<int16_t>(exponent);

 }

 bool Decimal::EncodedData::operator==(const EncodedData& another) const

 {

     return m_sign == another.m_sign

         && m_formatClass == another.m_formatClass

         && m_exponent == another.m_exponent

         && m_coefficient == another.m_coefficient;

 }

 Decimal::Decimal(int32_t i32)

     : m_data(i32 < 0 ? Negative : Positive, 0, i32 < 0 ? static_cast<uint64_t>(-static_cast<int64_t>(i32)) : static_cast<uint64_t>(i32))

 {

 }

 Decimal::Decimal(Sign sign, int exponent, uint64_t coefficient)

     : m_data(sign, coefficient ? exponent : 0, coefficient)

 {

 }

 Decimal::Decimal(const EncodedData& data)

     : m_data(data)

 {

 }

 Decimal::Decimal(const Decimal& other)

     : m_data(other.m_data)

 {

 }

 Decimal& Decimal::operator=(const Decimal& other)

 {

     m_data = other.m_data;

     return *this;

 }

 Decimal& Decimal::operator+=(const Decimal& other)

 {

     m_data = (*this + other).m_data;

     return *this;

 }

 Decimal& Decimal::operator-=(const Decimal& other)

 {

     m_data = (*this - other).m_data;

     return *this;

 }

 Decimal& Decimal::operator*=(const Decimal& other)

 {

     m_data = (*this * other).m_data;

     return *this;

 }

 Decimal& Decimal::operator/=(const Decimal& other)

 {

     m_data = (*this / other).m_data;

     return *this;

 }

 Decimal Decimal::operator-() const

 {

     if (isNaN())

         return *this;

     Decimal result(*this);

     result.m_data.setSign(invertSign(m_data.sign()));

     return result;

 }

 Decimal Decimal::operator+(const Decimal& rhs) const

 {

     const Decimal& lhs = *this;

     const Sign lhsSign = lhs.sign();

     const Sign rhsSign = rhs.sign();

     SpecialValueHandler handler(lhs, rhs);

     switch (handler.handle()) {

     case SpecialValueHandler::BothFinite:

         break;

     case SpecialValueHandler::BothInfinity:

         return lhsSign == rhsSign ? lhs : nan();

     case SpecialValueHandler::EitherNaN:

         return handler.value();

     case SpecialValueHandler::LHSIsInfinity:

         return lhs;

     case SpecialValueHandler::RHSIsInfinity:

         return rhs;

     }

     const AlignedOperands alignedOperands = alignOperands(lhs, rhs);

     const uint64_t result = lhsSign == rhsSign

         ? alignedOperands.lhsCoefficient + alignedOperands.rhsCoefficient

         : alignedOperands.lhsCoefficient - alignedOperands.rhsCoefficient;

     if (lhsSign == Negative && rhsSign == Positive && !result)

         return Decimal(Positive, alignedOperands.exponent, 0);

     return static_cast<int64_t>(result) >= 0

         ? Decimal(lhsSign, alignedOperands.exponent, result)

         : Decimal(invertSign(lhsSign), alignedOperands.exponent, -static_cast<int64_t>(result));

 }

 Decimal Decimal::operator-(const Decimal& rhs) const

 {

     const Decimal& lhs = *this;

     const Sign lhsSign = lhs.sign();

     const Sign rhsSign = rhs.sign();

     SpecialValueHandler handler(lhs, rhs);

     switch (handler.handle()) {

     case SpecialValueHandler::BothFinite:

         break;

     case SpecialValueHandler::BothInfinity:

         return lhsSign == rhsSign ? nan() : lhs;

     case SpecialValueHandler::EitherNaN:

         return handler.value();

     case SpecialValueHandler::LHSIsInfinity:

         return lhs;

     case SpecialValueHandler::RHSIsInfinity:

         return infinity(invertSign(rhsSign));

     }

     const AlignedOperands alignedOperands = alignOperands(lhs, rhs);

     const uint64_t result = lhsSign == rhsSign

         ? alignedOperands.lhsCoefficient - alignedOperands.rhsCoefficient

         : alignedOperands.lhsCoefficient + alignedOperands.rhsCoefficient;

     if (lhsSign == Negative && rhsSign == Negative && !result)

         return Decimal(Positive, alignedOperands.exponent, 0);

     return static_cast<int64_t>(result) >= 0

         ? Decimal(lhsSign, alignedOperands.exponent, result)

         : Decimal(invertSign(lhsSign), alignedOperands.exponent, -static_cast<int64_t>(result));

 }

 Decimal Decimal::operator*(const Decimal& rhs) const

 {

     const Decimal& lhs = *this;

     const Sign lhsSign = lhs.sign();

     const Sign rhsSign = rhs.sign();

     const Sign resultSign = lhsSign == rhsSign ? Positive : Negative;

     SpecialValueHandler handler(lhs, rhs);

     switch (handler.handle()) {

     case SpecialValueHandler::BothFinite: {

         const uint64_t lhsCoefficient = lhs.m_data.coefficient();

         const uint64_t rhsCoefficient = rhs.m_data.coefficient();

         int resultExponent = lhs.exponent() + rhs.exponent();

         UInt128 work(UInt128::multiply(lhsCoefficient, rhsCoefficient));

         while (work.high()) {

             work /= 10;

             ++resultExponent;

         }

         return Decimal(resultSign, resultExponent, work.low());

     }

     case SpecialValueHandler::BothInfinity:

         return infinity(resultSign);

     case SpecialValueHandler::EitherNaN:

         return handler.value();

     case SpecialValueHandler::LHSIsInfinity:

         return rhs.isZero() ? nan() : infinity(resultSign);

     case SpecialValueHandler::RHSIsInfinity:

         return lhs.isZero() ? nan() : infinity(resultSign);

     }

     ASSERT_NOT_REACHED();

     return nan();

 }

 Decimal Decimal::operator/(const Decimal& rhs) const

 {

     const Decimal& lhs = *this;

     const Sign lhsSign = lhs.sign();

     const Sign rhsSign = rhs.sign();

     const Sign resultSign = lhsSign == rhsSign ? Positive : Negative;

     SpecialValueHandler handler(lhs, rhs);

     switch (handler.handle()) {

     case SpecialValueHandler::BothFinite:

         break;

     case SpecialValueHandler::BothInfinity:

         return nan();

     case SpecialValueHandler::EitherNaN:

         return handler.value();

     case SpecialValueHandler::LHSIsInfinity:

         return infinity(resultSign);

     case SpecialValueHandler::RHSIsInfinity:

         return zero(resultSign);

     }

     ASSERT(lhs.isFinite());

     ASSERT(rhs.isFinite());

     if (rhs.isZero())

         return lhs.isZero() ? nan() : infinity(resultSign);

     int resultExponent = lhs.exponent() - rhs.exponent();

     if (lhs.isZero())

         return Decimal(resultSign, resultExponent, 0);

     uint64_t remainder = lhs.m_data.coefficient();

     const uint64_t divisor = rhs.m_data.coefficient();

     uint64_t result = 0;

     while (result < MaxCoefficient / 100) {

         while (remainder < divisor) {

             remainder *= 10;

             result *= 10;

             --resultExponent;

         }

         result += remainder / divisor;

         remainder %= divisor;

         if (!remainder)

             break;

     }

     if (remainder > divisor / 2)

         ++result;

     return Decimal(resultSign, resultExponent, result);

 }

 bool Decimal::operator==(const Decimal& rhs) const

 {

     if (isNaN() || rhs.isNaN())

         return false;

     return m_data == rhs.m_data || compareTo(rhs).isZero();

 }

 bool Decimal::operator!=(const Decimal& rhs) const

 {

     if (isNaN() || rhs.isNaN())

         return true;

     if (m_data == rhs.m_data)

         return false;

     const Decimal result = compareTo(rhs);

     if (result.isNaN())

         return false;

     return !result.isZero();

 }

 bool Decimal::operator<(const Decimal& rhs) const

 {

     const Decimal result = compareTo(rhs);

     if (result.isNaN())

         return false;

     return !result.isZero() && result.isNegative();

 }

 bool Decimal::operator<=(const Decimal& rhs) const

 {

     if (isNaN() || rhs.isNaN())

         return false;

     if (m_data == rhs.m_data)

         return true;

     const Decimal result = compareTo(rhs);

     if (result.isNaN())

         return false;

     return result.isZero() || result.isNegative();

 }

 bool Decimal::operator>(const Decimal& rhs) const

 {

     const Decimal result = compareTo(rhs);

     if (result.isNaN())

         return false;

     return !result.isZero() && result.isPositive();

 }

 bool Decimal::operator>=(const Decimal& rhs) const

 {

     if (isNaN() || rhs.isNaN())

         return false;

     if (m_data == rhs.m_data)

         return true;

     const Decimal result = compareTo(rhs);

     if (result.isNaN())

         return false;

     return result.isZero() || !result.isNegative();

 }

 Decimal Decimal::abs() const

 {

     Decimal result(*this);

     result.m_data.setSign(Positive);

     return result;

 }

 Decimal::AlignedOperands Decimal::alignOperands(const Decimal& lhs, const Decimal& rhs)

 {

     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;

 }

 // Round toward positive infinity.

 // Note: Mac ports defines ceil(x) as wtf_ceil(x), so we can't use name "ceil" here.

 Decimal Decimal::ceiling() const

 {

     if (isSpecial())

         return *this;

     if (exponent() >= 0)

         return *this;

     uint64_t coefficient = m_data.coefficient();

     const int numberOfDigits = countDigits(coefficient);

     const int numberOfDropDigits = -exponent();

     if (numberOfDigits < numberOfDropDigits)

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

     uint64_t result = scaleDown(coefficient, numberOfDropDigits);

     uint64_t droppedDigits = coefficient - scaleUp(result, numberOfDropDigits);

     if (droppedDigits && isPositive())

         result += 1;

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

 }

 Decimal Decimal::compareTo(const Decimal& rhs) const

 {

     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();

     }

 }

 // Round toward negative infinity.

 Decimal Decimal::floor() const

 {

     if (isSpecial())

         return *this;

     if (exponent() >= 0)

         return *this;

     uint64_t coefficient = m_data.coefficient();

     const int numberOfDigits = countDigits(coefficient);

     const int numberOfDropDigits = -exponent();

     if (numberOfDigits < numberOfDropDigits)

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

     uint64_t result = scaleDown(coefficient, numberOfDropDigits);

     uint64_t droppedDigits = coefficient - scaleUp(result, numberOfDropDigits);

     if (droppedDigits && isNegative()) {

         result += 1;

     }

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

 }

 Decimal Decimal::fromDouble(double doubleValue)

 {

     if (std::isfinite(doubleValue))

         return fromString(mozToString(doubleValue));

     if (std::isinf(doubleValue))

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

     return nan();

 }

 Decimal Decimal::fromString(const String& str)

 {

     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 (ch >= '0' && ch <= '9') {

                 if (numberOfDigits < Precision) {

                     ++numberOfDigits;

                     accumulator *= 10;

                     accumulator += ch - '0';

                 } else

                     ++numberOfExtraDigits;

                 break;

             }

             HandleCharAndBreak('.', StateDot);

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

             return nan();

         case StateDot:

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

                 if (numberOfDigits < Precision) {

                     ++numberOfDigits;

                     ++numberOfDigitsAfterDot;

                     accumulator *= 10;

                     accumulator += ch - '0';

                 }

                 state = StateDotDigit;

                 break;

             }

         case StateDotDigit:

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

                 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 (ch >= '0' && ch <= '9') {

                 exponent = ch - '0';

                 state = StateEDigit;

                 break;

             }

             return nan();

         case StateEDigit:

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

                 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 (ch >= '0' && ch <= '9') {

                 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);

             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 == StateEDigit || state == StateDotDigit) {

         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();

 }

 Decimal Decimal::infinity(const Sign sign)

 {

     return Decimal(EncodedData(sign, EncodedData::ClassInfinity));

 }

 Decimal Decimal::nan()

 {

     return Decimal(EncodedData(Positive, EncodedData::ClassNaN));

 }

 Decimal Decimal::remainder(const Decimal& rhs) const

 {

     const Decimal quotient = *this / rhs;

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

 }

 Decimal Decimal::round() const

 {

     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);

     // We're implementing round-half-away-from-zero, so we only need the one

     // (the most significant) fractional digit:

     result = scaleDown(result, numberOfDropDigits - 1);

     if (result % 10 >= 5)

         result += 10;

     result /= 10;

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

 }

 double Decimal::toDouble() const

 {

     if (isFinite()) {

         bool valid;

         const double doubleValue = mozToDouble(toString(), &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();

 }

 String Decimal::toString() const

 {

     switch (m_data.formatClass()) {

     case EncodedData::ClassInfinity:

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

     case EncodedData::ClassNaN:

         return "NaN";

     case EncodedData::ClassNormal:

     case EncodedData::ClassZero:

         break;

     default:

         ASSERT_NOT_REACHED();

         return "";

     }

     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 = mozToString(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();

         }

         if (adjustedExponent >= 0) {

             for (int i = 0; i < coefficientLength; ++i) {

                 builder.append(digits[i]);

                 if (i == adjustedExponent)

                     builder.append('.');

             }

             return builder.toString();

         }

         builder.appendLiteral("0.");

         for (int i = adjustedExponent + 1; i < 0; ++i)

             builder.append('0');

         builder.append(digits);

     } else {

         builder.append(digits[0]);

         while (coefficientLength >= 2 && digits[coefficientLength - 1] == '0')

             --coefficientLength;

         if (coefficientLength >= 2) {

             builder.append('.');

             for (int i = 1; i < coefficientLength; ++i)

                 builder.append(digits[i]);

         }

         if (adjustedExponent) {

             builder.append(adjustedExponent < 0 ? "e" : "e+");

             builder.appendNumber(adjustedExponent);

         }

     }

     return builder.toString();

 }

 bool Decimal::toString(char* strBuf, size_t bufLength) const

 {

   ASSERT(bufLength > 0);

   String str = toString();

   size_t length = str.copy(strBuf, bufLength);

   if (length < bufLength) {

     strBuf[length] = '\0';

     return true;

   }

   strBuf[bufLength - 1] = '\0';

   return false;

 }

 Decimal Decimal::zero(Sign sign)

 {

     return Decimal(EncodedData(sign, EncodedData::ClassZero));

 }

 } // namespace WebCore