Switch to vectors instead of bare char* arrays.

src/fast-dtoa.cc

 // 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
@@ skipping 43 matching lines @@
 // Input: * buffer containing the digits of too_high / 10^kappa
 //        * the buffer's length
 //        * distance_too_high_w == (too_high - w).f() * unit
 //        * unsafe_interval == (too_high - too_low).f() * unit
 //        * rest = (too_high - buffer * 10^kappa).f() * unit
 //        * ten_kappa = 10^kappa * unit
 //        * unit = the common multiplier
 // Output: returns true if the buffer is guaranteed to contain the closest
 //    representable number to the input.
 //  Modifies the generated digits in the buffer to approach (round towards) w.
-bool RoundWeed(char* buffer,
+bool RoundWeed(Vector<char> buffer,
                int length,
                uint64_t distance_too_high_w,
                uint64_t unsafe_interval,
                uint64_t rest,
                uint64_t ten_kappa,
                uint64_t unit) {
   uint64_t small_distance = distance_too_high_w - unit;
   uint64_t big_distance = distance_too_high_w + unit;
   // Let w_low  = too_high - big_distance, and
   //     w_high = too_high - small_distance.
@@ skipping 242 matching lines @@
 // get each digit. Example the first digit after the comma would be computed by
 //   (0x567890abcdef * 10) >> 48. -> 3
 // The whole thing becomes slightly more complicated because we want to stop
 // once we have enough digits. That is, once the digits inside the buffer
 // represent 'w' we can stop. Everything inside the interval low - high
 // represents w. However we have to pay attention to low, high and w's
 // imprecision.
 bool DigitGen(DiyFp low,
               DiyFp w,
               DiyFp high,
-              char* buffer,
+              Vector<char> buffer,
               int* length,
               int* kappa) {
   ASSERT(low.e() == w.e() && w.e() == high.e());
   ASSERT(low.f() + 1 <= high.f() - 1);
   ASSERT(minimal_target_exponent <= w.e() && w.e() <= maximal_target_exponent);
   // low, w and high are imprecise, but by less than one ulp (unit in the last
   // place).
   // If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
   // the new numbers are outside of the interval we want the final
   // representation to lie in.
@@ skipping 92 matching lines @@
 // Returns true if it succeeds, otherwise the result cannot be trusted.
 // There will be *length digits inside the buffer (not null-terminated).
 // If the function returns true then
 //        v == (double) (buffer * 10^decimal_exponent).
 // The digits in the buffer are the shortest representation possible: no
 // 0.09999999999999999 instead of 0.1. The shorter representation will even be
 // chosen even if the longer one would be closer to v.
 // The last digit will be closest to the actual v. That is, even if several
 // digits might correctly yield 'v' when read again, the closest will be
 // computed.
-bool grisu3(double v, char* buffer, int* length, int* decimal_exponent) {
+bool grisu3(double v, Vector<char> buffer, int* length, int* decimal_exponent) {
   DiyFp w = Double(v).AsNormalizedDiyFp();
   // boundary_minus and boundary_plus are the boundaries between v and its
   // closest floating-point neighbors. Any number strictly between
   // boundary_minus and boundary_plus will round to v when convert to a double.
   // Grisu3 will never output representations that lie exactly on a boundary.
   DiyFp boundary_minus, boundary_plus;
   Double(v).NormalizedBoundaries(&boundary_minus, &boundary_plus);
   ASSERT(boundary_plus.e() == w.e());
   DiyFp ten_mk;  // Cached power of ten: 10^-k
   int mk;        // -k
@@ skipping 30 matching lines @@
   // the buffer will be filled with "123" und the decimal_exponent will be
   // decreased by 2.
   int kappa;
   bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus,
                          buffer, length, &kappa);
   *decimal_exponent = -mk + kappa;
   return result;
 }
 
 
-bool FastDtoa(double v, char* buffer, int* sign, int* length, int* point) {
+bool FastDtoa(double v,
+              Vector<char> buffer,
+              int* sign,
+              int* length,
+              int* point) {
   ASSERT(v != 0);
   ASSERT(!Double(v).IsSpecial());
 
   if (v < 0) {
     v = -v;
     *sign = 1;
   } else {
     *sign = 0;
   }
   int decimal_exponent;
   bool result = grisu3(v, buffer, length, &decimal_exponent);
   *point = *length + decimal_exponent;
   buffer[*length] = '\0';
   return result;
 }
 
 } }  // namespace v8::internal