Fix assumptions in DoubleToFixed.

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 798 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 int kMaxDigitsBeforePoint = 21;
   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) {
     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.
+  // Add space for the '\0' byte.
   const int kDecimalRepCapacity =
-      kMaxDigitsBeforePoint + kMaxDigitsAfterPoint + 2;
+      kMaxDigitsBeforePoint + kMaxDigitsAfterPoint + 1;
   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);
 
   // Create a representation that is padded with zeros if needed.
   int zero_prefix_length = 0;
@@ skipping 275 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