| /* |
| * 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 aLow, uint64_t aHigh) |
| : m_high(aHigh), m_low(aLow) |
| { |
| } |
| |
| 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 aSign, FormatClass aFormatClass) |
| : m_coefficient(0) |
| , m_exponent(0) |
| , m_formatClass(aFormatClass) |
| , m_sign(aSign) |
| { |
| } |
| |
| Decimal::EncodedData::EncodedData(Sign aSign, int aExponent, uint64_t aCoefficient) |
| : m_formatClass(aCoefficient ? ClassNormal : ClassZero) |
| , m_sign(aSign) |
| { |
| if (aExponent >= ExponentMin && aExponent <= ExponentMax) { |
| while (aCoefficient > MaxCoefficient) { |
| aCoefficient /= 10; |
| ++aExponent; |
| } |
| } |
| |
| if (aExponent > ExponentMax) { |
| m_coefficient = 0; |
| m_exponent = 0; |
| m_formatClass = ClassInfinity; |
| return; |
| } |
| |
| if (aExponent < ExponentMin) { |
| m_coefficient = 0; |
| m_exponent = 0; |
| m_formatClass = ClassZero; |
| return; |
| } |
| |
| m_coefficient = aCoefficient; |
| m_exponent = static_cast<int16_t>(aExponent); |
| } |
| |
| 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 aSign, int aExponent, uint64_t aCoefficient) |
| : m_data(aSign, aCoefficient ? aExponent : 0, aCoefficient) |
| { |
| } |
| |
| 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 lhsRemainder = lhs.m_data.coefficient(); |
| const uint64_t divisor = rhs.m_data.coefficient(); |
| uint64_t result = 0; |
| while (result < MaxCoefficient / 100) { |
| while (lhsRemainder < divisor) { |
| lhsRemainder *= 10; |
| result *= 10; |
| --resultExponent; |
| } |
| result += lhsRemainder / divisor; |
| lhsRemainder %= divisor; |
| if (!lhsRemainder) |
| break; |
| } |
| |
| if (lhsRemainder > 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 |
| |
