Implement Double.{toString, toStringAsExponential, toStringAsPrecision}

runtime/vm/double_conversion.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/double_conversion.h"
 
 #include "third_party/double-conversion/src/double-conversion.h"
 
 #include "vm/exceptions.h"
 #include "vm/globals.h"
 #include "vm/object.h"
 
 namespace dart {
 
 static const char kDoubleToStringCommonExponentChar = 'e';
 static const char* kDoubleToStringCommonInfinitySymbol = "Infinity";
 static const char* kDoubleToStringCommonNaNSymbol = "NaN";
 
-bool DoubleToString(double d, String& result) {
+bool DoubleToCString(double d, char* buffer, int buffer_size,
+                     int* result_length) {
   static const int kDecimalLow = -6;
   static const int kDecimalHigh = 21;
+
+  // The output contains the sign, at most kDecimalHigh - 1 digits,
+  // the decimal point followed by a 0 plus the \0.
+  ASSERT(buffer_size >= 1 + (kDecimalHigh - 1) + 1 + 1 + 1);
+  // Or it contains the sign, a 0, the decimal point, kDecimalLow '0's,
+  // 17 digits (the precision needed for doubles), plus the \0.
+  ASSERT(buffer_size >= 1 + 1 + 1 + kDecimalLow + 17 + 1);
+  // Alternatively it contains a sign, at most 17 digits (precision needed for
+  // any double), the decimal point, the exponent character, the exponent's
+  // sign, at most three exponent digits, plus the \0.
+  ASSERT(buffer_size >= 1 + 17 + 1 + 1 + 1 + 3 + 1);
+
   static const int kConversionFlags =
       double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
       double_conversion::DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
      double_conversion::DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
-  const int kBufferSize = 128;
-  // The output contains the sign, at most kDecimalHigh - 1 digits,
-  // the decimal point followed by a 0 plus the \0.
-  ASSERT(kBufferSize >= 1 + (kDecimalHigh - 1) + 1 + 1 + 1);
-  // Or it contains the sign, a 0, the decimal point, kDecimalLow '0's,
-  // 17 digits (the precision needed for doubles), plus the \0.
-  ASSERT(kBufferSize >= 1 + 1 + 1 + kDecimalLow + 17 + 1);
-  // Alternatively it contains a sign, at most 17 digits (precision needed for
-  // any double), the decimal point, the exponent character, the exponent's
-  // sign, at most three exponent digits, plus the \0.
-  ASSERT(kBufferSize >= 1 + 17 + 1 + 1 + 1 + 3 + 1);
 
   const double_conversion::DoubleToStringConverter converter(
       kConversionFlags,
       kDoubleToStringCommonInfinitySymbol,
       kDoubleToStringCommonNaNSymbol,
       kDoubleToStringCommonExponentChar,
       kDecimalLow,
       kDecimalHigh,
       0, 0);  // Last two values are ignored in shortest mode.
 
-  UNIMPLEMENTED();
-  return false;
+  double_conversion::StringBuilder builder(buffer, buffer_size);
+  bool status = converter.ToShortest(d, &builder);
+  if (!status) return false;
+  *result_length = builder.position() + 1;  // Include trailing \0 character.
+  char* result = builder.Finalize();
+  ASSERT(result == buffer);
+  return true;
 }
 
-bool DoubleToStringAsFixed(double d, int fraction_digits, String& result) {
+RawString* DoubleToStringAsFixed(double d, int fraction_digits) {
   static const int kMinFractionDigits = 0;
   static const int kMaxFractionDigits = 20;
   static const int kMaxDigitsBeforePoint = 20;
   // The boundaries are exclusive.
   static const double kLowerBoundary = -1e21;
   static const double kUpperBoundary = 1e21;
   // TODO(floitsch): remove the UNIQUE_ZERO flag when the test is updated.
   static const int kConversionFlags =
-      double_conversion::DoubleToStringConverter::UNIQUE_ZERO;
+      double_conversion::DoubleToStringConverter::NO_FLAGS;
   const int kBufferSize = 128;
+
+  USE(kMaxDigitsBeforePoint);
+  USE(kMaxFractionDigits);
+  USE(kMinFractionDigits);
+  USE(kMaxFractionDigits);
   // The output contains the sign, at most kMaxDigitsBeforePoint digits,
   // the decimal point followed by at most fraction_digits digits plus the \0.
   ASSERT(kBufferSize >= 1 + kMaxDigitsBeforePoint + 1 + kMaxFractionDigits + 1);
 
   if (d <= kLowerBoundary || d >= kUpperBoundary) {
-    return false;
+    return NULL;

[Ivan Posva, 2012/02/06 18:25:44]

I am sorry I missed this on the first read of this code: NULL is not a legal
RawString*. Please use "String::null()" instead.

Explanation: NULL in C++ is defined to be a pointer with all bits being 0, which
maps to a Smi with value zero in Dart.

Since your code here and in related functions in this file do not match the
expectation in your fixed code "if result.IsNull()" it looks to me as if you
also need to add some tests for that scenario.

[floitsch, 2012/02/11 22:42:30]

done.
Changed this occurrence to an ASSERT.

   }
-  if (fraction_digits < kMinFractionDigits ||
-      fraction_digits > kMaxFractionDigits) {
-    return false;
-  }
+  assert(kMinFractionDigits <= fraction_digits &&
+         fraction_digits <= kMaxFractionDigits);
 
   const double_conversion::DoubleToStringConverter converter(
       kConversionFlags,
       kDoubleToStringCommonInfinitySymbol,
       kDoubleToStringCommonNaNSymbol,
       kDoubleToStringCommonExponentChar,
       0, 0, 0, 0);  // Last four values are ignored in fixed mode.
 
   char buffer[kBufferSize];
   double_conversion::StringBuilder builder(buffer, kBufferSize);
   bool status = converter.ToFixed(d, fraction_digits, &builder);
-  if (!status) return false;
+  if (!status) return NULL;

[floitsch, 2012/02/11 22:42:30]

changed to String::null().
status is supposed to always be true. Should I change this (here and in the
other conversion routines) to an ASSERT?

[Ivan Posva, 2012/02/27 14:47:14]

What will happen in production when the status is not true? Will we get a bad
string conversion (e.g. partial or empty string), a null string from the builder
or a crash?

[floitsch, 2012/02/27 19:55:40]

The string builder only wraps the raw char-array to make verifications. If the
double-conversion fails the result would be partial or empty.

   int length = builder.position();
-  result ^= String::New(reinterpret_cast<uint8_t*>(builder.Finalize()), length);
-  return true;
+  return String::New(reinterpret_cast<uint8_t*>(builder.Finalize()), length);
 }
 
 
-bool DoubleToStringAsExponential(double d,
-                                 int fraction_digits,
-                                 String& result) {
-  static const int kMinFractionDigits = 0;
+RawString* DoubleToStringAsExponential(double d, int fraction_digits) {
+  static const int kMinFractionDigits = -1;  // -1 represents shortest mode.
   static const int kMaxFractionDigits = 20;
   static const int kConversionFlags =
       double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
   const int kBufferSize = 128;
+
+  USE(kMinFractionDigits);
+  USE(kMaxFractionDigits);
   // The output contains the sign, at most 1 digits, the decimal point followed
   // by at most kMaxFractionDigits digits, the exponent-character, the
   // exponent-sign and three exponent digits plus \0.
   ASSERT(kBufferSize >= 1 + 1 + kMaxFractionDigits + 1 + 1 + 3 + 1);
 
-  if (!(kMinFractionDigits <= fraction_digits &&
-        fraction_digits <= kMaxFractionDigits)) {
-    return false;
-  }
+  assert(kMinFractionDigits <= fraction_digits &&
+         fraction_digits <= kMaxFractionDigits);
 
   const double_conversion::DoubleToStringConverter converter(
       kConversionFlags,
       kDoubleToStringCommonInfinitySymbol,
       kDoubleToStringCommonNaNSymbol,
       kDoubleToStringCommonExponentChar,
       0, 0, 0, 0);  // Last four values are ignored in exponential mode.
 
-  UNIMPLEMENTED();
-  return false;
+  char buffer[kBufferSize];
+  double_conversion::StringBuilder builder(buffer, kBufferSize);
+  bool status = converter.ToExponential(d, fraction_digits, &builder);
+  if (!status) return NULL;
+  int length = builder.position();
+  return String::New(reinterpret_cast<uint8_t*>(builder.Finalize()), length);
 }
 
 
-bool DoubleToStringAsPrecision(double d, int precision, String& result) {
+RawString* DoubleToStringAsPrecision(double d, int precision) {
   static const int kMinPrecisionDigits = 1;
   static const int kMaxPrecisionDigits = 21;
   static const int kMaxLeadingPaddingZeroes = 6;
   static const int kMaxTrailingPaddingZeroes = 0;
   static const int kConversionFlags =
       double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
   const int kBufferSize = 128;
+
+  USE(kMinPrecisionDigits);
+  USE(kMaxPrecisionDigits);
   // The output contains the sign, the decimal point, precision digits,
   // the exponent-character, the exponent-sign, three exponent digits
   // plus the \0.
   ASSERT(kBufferSize >= 1 + 1 + kMaxPrecisionDigits + 1 + 1 + 3 + 1);
 
-  if (!(kMinPrecisionDigits <= precision && precision <= kMaxPrecisionDigits)) {
-    return false;
-  }
+  assert(kMinPrecisionDigits <= precision && precision <= kMaxPrecisionDigits);
 
   const double_conversion::DoubleToStringConverter converter(
       kConversionFlags,
       kDoubleToStringCommonInfinitySymbol,
       kDoubleToStringCommonNaNSymbol,
       kDoubleToStringCommonExponentChar,
       0, 0,  // Ignored in precision mode.
       kMaxLeadingPaddingZeroes,
       kMaxTrailingPaddingZeroes);
 
-  UNIMPLEMENTED();
-  return false;
+  char buffer[kBufferSize];
+  double_conversion::StringBuilder builder(buffer, kBufferSize);
+  bool status = converter.ToPrecision(d, precision, &builder);
+  if (!status) return NULL;
+  int length = builder.position();
+  return String::New(reinterpret_cast<uint8_t*>(builder.Finalize()), length);
 }
 
 }  // namespace dart