Revert r4591

src/conversions.cc

 // Copyright 2006-2008 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
@@ skipping 13 matching lines @@
 // 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 <stdarg.h>
 #include <limits.h>
 
 #include "v8.h"
 
 #include "conversions-inl.h"
-#include "dtoa.h"
 #include "factory.h"
+#include "fast-dtoa.h"
 #include "scanner.h"
 
 namespace v8 {
 namespace internal {
 
 int HexValue(uc32 c) {
   if ('0' <= c && c <= '9')
     return c - '0';
   if ('a' <= c && c <= 'f')
     return c - 'a' + 10;
@@ skipping 713 matching lines @@
       }
       break;
 
     case FP_ZERO:
       builder.AddCharacter('0');
       break;
 
     default: {
       int decimal_point;
       int sign;
+
       char* decimal_rep;
       bool used_gay_dtoa = false;
-      const int kV8DtoaBufferCapacity = kBase10MaximalLength + 1;
-      char v8_dtoa_buffer[kV8DtoaBufferCapacity];
+      const int kFastDtoaBufferCapacity = kFastDtoaMaximalLength + 1;
+      char fast_dtoa_buffer[kFastDtoaBufferCapacity];
       int length;
-
-      if (DoubleToAscii(v, DTOA_SHORTEST, 0,
-                        Vector<char>(v8_dtoa_buffer, kV8DtoaBufferCapacity),
-                        &sign, &length, &decimal_point)) {
-        decimal_rep = v8_dtoa_buffer;
+      if (FastDtoa(v, Vector<char>(fast_dtoa_buffer, kFastDtoaBufferCapacity),
+                   &sign, &length, &decimal_point)) {
+        decimal_rep = fast_dtoa_buffer;
       } else {
         decimal_rep = dtoa(v, 0, 0, &decimal_point, &sign, NULL);
         used_gay_dtoa = true;
         length = StrLength(decimal_rep);
       }
 
       if (sign) builder.AddCharacter('-');
 
       if (length <= decimal_point && decimal_point <= 21) {
         // ECMA-262 section 9.8.1 step 6.
@@ skipping 47 matching lines @@
   do {
     buffer[--i] = '0' + (n % 10);
     n /= 10;
   } while (n);
   if (negative) buffer[--i] = '-';
   return buffer.start() + i;
 }
 
 
 char* DoubleToFixedCString(double value, int f) {
-  const int kMaxDigitsBeforePoint = 20;
-  const double kFirstNonFixed = 1e21;
-  const int kMaxDigitsAfterPoint = 20;
   ASSERT(f >= 0);
-  ASSERT(f <= kMaxDigitsAfterPoint);
 
   bool negative = false;
   double abs_value = value;
   if (value < 0) {
     abs_value = -value;
     negative = true;
   }
 
-  // If abs_value has more than kMaxDigitsBeforePoint digits before the point
-  // use the non-fixed conversion routine.
-  if (abs_value >= kFirstNonFixed) {
+  if (abs_value >= 1e21) {
     char arr[100];
     Vector<char> buffer(arr, ARRAY_SIZE(arr));
     return StrDup(DoubleToCString(value, buffer));
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
-  // Add space for the '.' and the '\0' byte.
-  const int kDecimalRepCapacity =
-      kMaxDigitsBeforePoint + kMaxDigitsAfterPoint + 2;
-  char decimal_rep[kDecimalRepCapacity];
-  int decimal_rep_length;
-  bool status = DoubleToAscii(value, DTOA_FIXED, f,
-                              Vector<char>(decimal_rep, kDecimalRepCapacity),
-                              &sign, &decimal_rep_length, &decimal_point);
-  USE(status);
-  ASSERT(status);
+  char* decimal_rep = dtoa(abs_value, 3, f, &decimal_point, &sign, NULL);
+  int decimal_rep_length = StrLength(decimal_rep);
 
   // Create a representation that is padded with zeros if needed.
   int zero_prefix_length = 0;
   int zero_postfix_length = 0;
 
   if (decimal_point <= 0) {
     zero_prefix_length = -decimal_point + 1;
     decimal_point = 1;
   }
 
   if (zero_prefix_length + decimal_rep_length < decimal_point + f) {
     zero_postfix_length = decimal_point + f - decimal_rep_length -
                           zero_prefix_length;
   }
 
   unsigned rep_length =
       zero_prefix_length + decimal_rep_length + zero_postfix_length;
   StringBuilder rep_builder(rep_length + 1);
   rep_builder.AddPadding('0', zero_prefix_length);
   rep_builder.AddString(decimal_rep);
   rep_builder.AddPadding('0', zero_postfix_length);
   char* rep = rep_builder.Finalize();
+  freedtoa(decimal_rep);
 
   // Create the result string by appending a minus and putting in a
   // decimal point if needed.
   unsigned result_size = decimal_point + f + 2;
   StringBuilder builder(result_size + 1);
   if (negative) builder.AddCharacter('-');
   builder.AddSubstring(rep, decimal_point);
   if (f > 0) {
     builder.AddCharacter('.');
     builder.AddSubstring(rep + decimal_point, f);
@@ skipping 198 matching lines @@
   // Allocate result and fill in the parts.
   StringBuilder builder(result_size + 1);
   builder.AddSubstring(integer_buffer + integer_pos + 1, integer_part_size);
   if (decimal_pos > 0) builder.AddCharacter('.');
   builder.AddSubstring(decimal_buffer, decimal_pos);
   return builder.Finalize();
 }
 
 
 } }  // namespace v8::internal