| // © 2018 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| // |
| // From the double-conversion library. Original license: |
| // |
| // Copyright 2010 the V8 project authors. 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. |
| |
| // ICU PATCH: ifdef around UCONFIG_NO_FORMATTING |
| #include "unicode/utypes.h" |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include <algorithm> |
| #include <climits> |
| #include <cmath> |
| |
| // ICU PATCH: Customize header file paths for ICU. |
| // The file fixed-dtoa.h is not needed. |
| |
| #include "double-conversion-double-to-string.h" |
| |
| #include "double-conversion-bignum-dtoa.h" |
| #include "double-conversion-fast-dtoa.h" |
| #include "double-conversion-ieee.h" |
| #include "double-conversion-utils.h" |
| |
| // ICU PATCH: Wrap in ICU namespace |
| U_NAMESPACE_BEGIN |
| |
| namespace double_conversion { |
| |
| #if 0 // not needed for ICU |
| const DoubleToStringConverter& DoubleToStringConverter::EcmaScriptConverter() { |
| int flags = UNIQUE_ZERO | EMIT_POSITIVE_EXPONENT_SIGN; |
| static DoubleToStringConverter converter(flags, |
| "Infinity", |
| "NaN", |
| 'e', |
| -6, 21, |
| 6, 0); |
| return converter; |
| } |
| |
| |
| bool DoubleToStringConverter::HandleSpecialValues( |
| double value, |
| StringBuilder* result_builder) const { |
| Double double_inspect(value); |
| if (double_inspect.IsInfinite()) { |
| if (infinity_symbol_ == NULL) return false; |
| if (value < 0) { |
| result_builder->AddCharacter('-'); |
| } |
| result_builder->AddString(infinity_symbol_); |
| return true; |
| } |
| if (double_inspect.IsNan()) { |
| if (nan_symbol_ == NULL) return false; |
| result_builder->AddString(nan_symbol_); |
| return true; |
| } |
| return false; |
| } |
| |
| |
| void DoubleToStringConverter::CreateExponentialRepresentation( |
| const char* decimal_digits, |
| int length, |
| int exponent, |
| StringBuilder* result_builder) const { |
| DOUBLE_CONVERSION_ASSERT(length != 0); |
| result_builder->AddCharacter(decimal_digits[0]); |
| if (length != 1) { |
| result_builder->AddCharacter('.'); |
| result_builder->AddSubstring(&decimal_digits[1], length-1); |
| } |
| result_builder->AddCharacter(exponent_character_); |
| if (exponent < 0) { |
| result_builder->AddCharacter('-'); |
| exponent = -exponent; |
| } else { |
| if ((flags_ & EMIT_POSITIVE_EXPONENT_SIGN) != 0) { |
| result_builder->AddCharacter('+'); |
| } |
| } |
| DOUBLE_CONVERSION_ASSERT(exponent < 1e4); |
| // Changing this constant requires updating the comment of DoubleToStringConverter constructor |
| const int kMaxExponentLength = 5; |
| char buffer[kMaxExponentLength + 1]; |
| buffer[kMaxExponentLength] = '\0'; |
| int first_char_pos = kMaxExponentLength; |
| if (exponent == 0) { |
| buffer[--first_char_pos] = '0'; |
| } else { |
| while (exponent > 0) { |
| buffer[--first_char_pos] = '0' + (exponent % 10); |
| exponent /= 10; |
| } |
| } |
| // Add prefix '0' to make exponent width >= min(min_exponent_with_, kMaxExponentLength) |
| // For example: convert 1e+9 -> 1e+09, if min_exponent_with_ is set to 2 |
| while(kMaxExponentLength - first_char_pos < std::min(min_exponent_width_, kMaxExponentLength)) { |
| buffer[--first_char_pos] = '0'; |
| } |
| result_builder->AddSubstring(&buffer[first_char_pos], |
| kMaxExponentLength - first_char_pos); |
| } |
| |
| |
| void DoubleToStringConverter::CreateDecimalRepresentation( |
| const char* decimal_digits, |
| int length, |
| int decimal_point, |
| int digits_after_point, |
| StringBuilder* result_builder) const { |
| // Create a representation that is padded with zeros if needed. |
| if (decimal_point <= 0) { |
| // "0.00000decimal_rep" or "0.000decimal_rep00". |
| result_builder->AddCharacter('0'); |
| if (digits_after_point > 0) { |
| result_builder->AddCharacter('.'); |
| result_builder->AddPadding('0', -decimal_point); |
| DOUBLE_CONVERSION_ASSERT(length <= digits_after_point - (-decimal_point)); |
| result_builder->AddSubstring(decimal_digits, length); |
| int remaining_digits = digits_after_point - (-decimal_point) - length; |
| result_builder->AddPadding('0', remaining_digits); |
| } |
| } else if (decimal_point >= length) { |
| // "decimal_rep0000.00000" or "decimal_rep.0000". |
| result_builder->AddSubstring(decimal_digits, length); |
| result_builder->AddPadding('0', decimal_point - length); |
| if (digits_after_point > 0) { |
| result_builder->AddCharacter('.'); |
| result_builder->AddPadding('0', digits_after_point); |
| } |
| } else { |
| // "decima.l_rep000". |
| DOUBLE_CONVERSION_ASSERT(digits_after_point > 0); |
| result_builder->AddSubstring(decimal_digits, decimal_point); |
| result_builder->AddCharacter('.'); |
| DOUBLE_CONVERSION_ASSERT(length - decimal_point <= digits_after_point); |
| result_builder->AddSubstring(&decimal_digits[decimal_point], |
| length - decimal_point); |
| int remaining_digits = digits_after_point - (length - decimal_point); |
| result_builder->AddPadding('0', remaining_digits); |
| } |
| if (digits_after_point == 0) { |
| if ((flags_ & EMIT_TRAILING_DECIMAL_POINT) != 0) { |
| result_builder->AddCharacter('.'); |
| } |
| if ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) { |
| result_builder->AddCharacter('0'); |
| } |
| } |
| } |
| |
| |
| bool DoubleToStringConverter::ToShortestIeeeNumber( |
| double value, |
| StringBuilder* result_builder, |
| DoubleToStringConverter::DtoaMode mode) const { |
| DOUBLE_CONVERSION_ASSERT(mode == SHORTEST || mode == SHORTEST_SINGLE); |
| if (Double(value).IsSpecial()) { |
| return HandleSpecialValues(value, result_builder); |
| } |
| |
| int decimal_point; |
| bool sign; |
| const int kDecimalRepCapacity = kBase10MaximalLength + 1; |
| char decimal_rep[kDecimalRepCapacity]; |
| int decimal_rep_length; |
| |
| DoubleToAscii(value, mode, 0, decimal_rep, kDecimalRepCapacity, |
| &sign, &decimal_rep_length, &decimal_point); |
| |
| bool unique_zero = (flags_ & UNIQUE_ZERO) != 0; |
| if (sign && (value != 0.0 || !unique_zero)) { |
| result_builder->AddCharacter('-'); |
| } |
| |
| int exponent = decimal_point - 1; |
| if ((decimal_in_shortest_low_ <= exponent) && |
| (exponent < decimal_in_shortest_high_)) { |
| CreateDecimalRepresentation(decimal_rep, decimal_rep_length, |
| decimal_point, |
| (std::max)(0, decimal_rep_length - decimal_point), |
| result_builder); |
| } else { |
| CreateExponentialRepresentation(decimal_rep, decimal_rep_length, exponent, |
| result_builder); |
| } |
| return true; |
| } |
| |
| |
| bool DoubleToStringConverter::ToFixed(double value, |
| int requested_digits, |
| StringBuilder* result_builder) const { |
| DOUBLE_CONVERSION_ASSERT(kMaxFixedDigitsBeforePoint == 60); |
| const double kFirstNonFixed = 1e60; |
| |
| if (Double(value).IsSpecial()) { |
| return HandleSpecialValues(value, result_builder); |
| } |
| |
| if (requested_digits > kMaxFixedDigitsAfterPoint) return false; |
| if (value >= kFirstNonFixed || value <= -kFirstNonFixed) return false; |
| |
| // Find a sufficiently precise decimal representation of n. |
| int decimal_point; |
| bool sign; |
| // Add space for the '\0' byte. |
| const int kDecimalRepCapacity = |
| kMaxFixedDigitsBeforePoint + kMaxFixedDigitsAfterPoint + 1; |
| char decimal_rep[kDecimalRepCapacity]; |
| int decimal_rep_length; |
| DoubleToAscii(value, FIXED, requested_digits, |
| decimal_rep, kDecimalRepCapacity, |
| &sign, &decimal_rep_length, &decimal_point); |
| |
| bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0); |
| if (sign && (value != 0.0 || !unique_zero)) { |
| result_builder->AddCharacter('-'); |
| } |
| |
| CreateDecimalRepresentation(decimal_rep, decimal_rep_length, decimal_point, |
| requested_digits, result_builder); |
| return true; |
| } |
| |
| |
| bool DoubleToStringConverter::ToExponential( |
| double value, |
| int requested_digits, |
| StringBuilder* result_builder) const { |
| if (Double(value).IsSpecial()) { |
| return HandleSpecialValues(value, result_builder); |
| } |
| |
| if (requested_digits < -1) return false; |
| if (requested_digits > kMaxExponentialDigits) return false; |
| |
| int decimal_point; |
| bool sign; |
| // Add space for digit before the decimal point and the '\0' character. |
| const int kDecimalRepCapacity = kMaxExponentialDigits + 2; |
| DOUBLE_CONVERSION_ASSERT(kDecimalRepCapacity > kBase10MaximalLength); |
| char decimal_rep[kDecimalRepCapacity]; |
| #ifndef NDEBUG |
| // Problem: there is an assert in StringBuilder::AddSubstring() that |
| // will pass this buffer to strlen(), and this buffer is not generally |
| // null-terminated. |
| memset(decimal_rep, 0, sizeof(decimal_rep)); |
| #endif |
| int decimal_rep_length; |
| |
| if (requested_digits == -1) { |
| DoubleToAscii(value, SHORTEST, 0, |
| decimal_rep, kDecimalRepCapacity, |
| &sign, &decimal_rep_length, &decimal_point); |
| } else { |
| DoubleToAscii(value, PRECISION, requested_digits + 1, |
| decimal_rep, kDecimalRepCapacity, |
| &sign, &decimal_rep_length, &decimal_point); |
| DOUBLE_CONVERSION_ASSERT(decimal_rep_length <= requested_digits + 1); |
| |
| for (int i = decimal_rep_length; i < requested_digits + 1; ++i) { |
| decimal_rep[i] = '0'; |
| } |
| decimal_rep_length = requested_digits + 1; |
| } |
| |
| bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0); |
| if (sign && (value != 0.0 || !unique_zero)) { |
| result_builder->AddCharacter('-'); |
| } |
| |
| int exponent = decimal_point - 1; |
| CreateExponentialRepresentation(decimal_rep, |
| decimal_rep_length, |
| exponent, |
| result_builder); |
| return true; |
| } |
| |
| |
| bool DoubleToStringConverter::ToPrecision(double value, |
| int precision, |
| StringBuilder* result_builder) const { |
| if (Double(value).IsSpecial()) { |
| return HandleSpecialValues(value, result_builder); |
| } |
| |
| if (precision < kMinPrecisionDigits || precision > kMaxPrecisionDigits) { |
| return false; |
| } |
| |
| // Find a sufficiently precise decimal representation of n. |
| int decimal_point; |
| bool sign; |
| // Add one for the terminating null character. |
| const int kDecimalRepCapacity = kMaxPrecisionDigits + 1; |
| char decimal_rep[kDecimalRepCapacity]; |
| int decimal_rep_length; |
| |
| DoubleToAscii(value, PRECISION, precision, |
| decimal_rep, kDecimalRepCapacity, |
| &sign, &decimal_rep_length, &decimal_point); |
| DOUBLE_CONVERSION_ASSERT(decimal_rep_length <= precision); |
| |
| bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0); |
| if (sign && (value != 0.0 || !unique_zero)) { |
| result_builder->AddCharacter('-'); |
| } |
| |
| // The exponent if we print the number as x.xxeyyy. That is with the |
| // decimal point after the first digit. |
| int exponent = decimal_point - 1; |
| |
| int extra_zero = ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) ? 1 : 0; |
| bool as_exponential = |
| (-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) || |
| (decimal_point - precision + extra_zero > |
| max_trailing_padding_zeroes_in_precision_mode_); |
| if ((flags_ & NO_TRAILING_ZERO) != 0) { |
| // Truncate trailing zeros that occur after the decimal point (if exponential, |
| // that is everything after the first digit). |
| int stop = as_exponential ? 1 : std::max(1, decimal_point); |
| while (decimal_rep_length > stop && decimal_rep[decimal_rep_length - 1] == '0') { |
| --decimal_rep_length; |
| } |
| // Clamp precision to avoid the code below re-adding the zeros. |
| precision = std::min(precision, decimal_rep_length); |
| } |
| if (as_exponential) { |
| // Fill buffer to contain 'precision' digits. |
| // Usually the buffer is already at the correct length, but 'DoubleToAscii' |
| // is allowed to return less characters. |
| for (int i = decimal_rep_length; i < precision; ++i) { |
| decimal_rep[i] = '0'; |
| } |
| |
| CreateExponentialRepresentation(decimal_rep, |
| precision, |
| exponent, |
| result_builder); |
| } else { |
| CreateDecimalRepresentation(decimal_rep, decimal_rep_length, decimal_point, |
| (std::max)(0, precision - decimal_point), |
| result_builder); |
| } |
| return true; |
| } |
| #endif // not needed for ICU |
| |
| |
| static BignumDtoaMode DtoaToBignumDtoaMode( |
| DoubleToStringConverter::DtoaMode dtoa_mode) { |
| switch (dtoa_mode) { |
| case DoubleToStringConverter::SHORTEST: return BIGNUM_DTOA_SHORTEST; |
| case DoubleToStringConverter::SHORTEST_SINGLE: |
| return BIGNUM_DTOA_SHORTEST_SINGLE; |
| case DoubleToStringConverter::FIXED: return BIGNUM_DTOA_FIXED; |
| case DoubleToStringConverter::PRECISION: return BIGNUM_DTOA_PRECISION; |
| default: |
| DOUBLE_CONVERSION_UNREACHABLE(); |
| } |
| } |
| |
| |
| void DoubleToStringConverter::DoubleToAscii(double v, |
| DtoaMode mode, |
| int requested_digits, |
| char* buffer, |
| int buffer_length, |
| bool* sign, |
| int* length, |
| int* point) { |
| Vector<char> vector(buffer, buffer_length); |
| DOUBLE_CONVERSION_ASSERT(!Double(v).IsSpecial()); |
| DOUBLE_CONVERSION_ASSERT(mode == SHORTEST || mode == SHORTEST_SINGLE || requested_digits >= 0); |
| |
| if (Double(v).Sign() < 0) { |
| *sign = true; |
| v = -v; |
| } else { |
| *sign = false; |
| } |
| |
| if (mode == PRECISION && requested_digits == 0) { |
| vector[0] = '\0'; |
| *length = 0; |
| return; |
| } |
| |
| if (v == 0) { |
| vector[0] = '0'; |
| vector[1] = '\0'; |
| *length = 1; |
| *point = 1; |
| return; |
| } |
| |
| bool fast_worked; |
| switch (mode) { |
| case SHORTEST: |
| fast_worked = FastDtoa(v, FAST_DTOA_SHORTEST, 0, vector, length, point); |
| break; |
| #if 0 // not needed for ICU |
| case SHORTEST_SINGLE: |
| fast_worked = FastDtoa(v, FAST_DTOA_SHORTEST_SINGLE, 0, |
| vector, length, point); |
| break; |
| case FIXED: |
| fast_worked = FastFixedDtoa(v, requested_digits, vector, length, point); |
| break; |
| case PRECISION: |
| fast_worked = FastDtoa(v, FAST_DTOA_PRECISION, requested_digits, |
| vector, length, point); |
| break; |
| #endif // not needed for ICU |
| default: |
| fast_worked = false; |
| DOUBLE_CONVERSION_UNREACHABLE(); |
| } |
| if (fast_worked) return; |
| |
| // If the fast dtoa didn't succeed use the slower bignum version. |
| BignumDtoaMode bignum_mode = DtoaToBignumDtoaMode(mode); |
| BignumDtoa(v, bignum_mode, requested_digits, vector, length, point); |
| vector[*length] = '\0'; |
| } |
| |
| } // namespace double_conversion |
| |
| // ICU PATCH: Close ICU namespace |
| U_NAMESPACE_END |
| #endif // ICU PATCH: close #if !UCONFIG_NO_FORMATTING |