Restoring authorship annotation for <mcheshkov@yandex-team.ru>. Commit 1 of 2.

1 files changed, 450 insertions, 450 deletions

diff --git a/contrib/libs/icu/i18n/double-conversion-double-to-string.cpp b/contrib/libs/icu/i18n/double-conversion-double-to-string.cpp
index 44c176f4f9..11fa69be04 100644
--- a/contrib/libs/icu/i18n/double-conversion-double-to-string.cpp
+++ b/contrib/libs/icu/i18n/double-conversion-double-to-string.cpp
@@ -1,450 +1,450 @@
-// © 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('+');
-    }
-  }
-  if (exponent == 0) {
-    result_builder->AddCharacter('0');
-    return;
-  }
-  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;
-  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;
-  if ((-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) ||
-      (decimal_point - precision + extra_zero >
-       max_trailing_padding_zeroes_in_precision_mode_)) {
-    // 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
+// © 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('+'); 
+    } 
+  } 
+  if (exponent == 0) { 
+    result_builder->AddCharacter('0'); 
+    return; 
+  } 
+  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; 
+  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; 
+  if ((-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) || 
+      (decimal_point - precision + extra_zero > 
+       max_trailing_padding_zeroes_in_precision_mode_)) { 
+    // 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