Implement Double.toStringAsFixed.

runtime/lib/double.dart

 // 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.
 
 class Double implements double {
   factory Double.fromInteger(int value)
       native "Double_doubleFromInteger";
   int hashCode() {
     try {
       return toInt();
@@ skipping 90 matching lines @@
   }
 
   double round() native "Double_round";
   double floor() native "Double_floor";
   double ceil () native "Double_ceil";
   double truncate() native "Double_truncate";
   int toInt() native "Double_toInt";
   double toDouble() { return this; }
 
   double pow(num exponent) {
-    return pow_(exponent.toDouble());
+    return _pow(exponent.toDouble());
   }
-  double pow_(double exponent) native "Double_pow";
+  double _pow(double exponent) native "Double_pow";
 
   String toStringAsFixed(int fractionDigits) {
     // See ECMAScript-262, 15.7.4.5 for details.
 
     // Step 2.
     if (fractionDigits < 0 || fractionDigits > 20) {
       // TODO(antonm): should be proper RangeError or Dart counterpart.
       throw "Range error";
     }
 
     // Step 3.
     double x = this;
 
     // Step 4.
-    if (x.isNaN()) {
-      return "NaN";
+    if (isNaN()) return "NaN";
+
+    // Step 5 and 6 skipped. Will be dealt with by native function.
+
+    // Step 7.
+    if (x >= 1e21 || x <= -1e21) {
+      return x.toString();
     }
 
-    // Step 5.
-    String s = "";
+    return _toStringAsFixed(fractionDigits);
+  }
+  String _toStringAsFixed(int fractionDigits) native "Double_toStringAsFixed";
 
-    // Step 6.
-    if (x.isNegative() && x != 0.0) {
-      s = "-";
-      x = -x;
+  String toStringAsExponential(int fractionDigits) {
+    // See ECMAScript-262, 15.7.4.6 for details.
+
+    // The EcmaScript specification checks for NaN and Infinity before looking
+    // at the fractionDigits. In Dart we are consistent with toStringAsFixed and
+    // look at the fractionDigits first.
+
+    // Step 7.
+    if (fractionDigits < 0 || fractionDigits > 20) {
+      // TODO(antonm): should be proper RangeError or Dart counterpart.
+      throw "Range error";
     }
 
-    // Step 7.
-    String m;
-    if (x > 10e21) {
-      m = x.toString();
-    } else {
-      // Step 8.
+    return _toStringAsExponential(fractionDigits);
+  }
+  String _toStringAsExponential(int fractionDigits)
+      native "Double_toStringAsExponential";
 
-      // Step 8.a.
-      // This is an approximation for n from the standard.
-      int n = (x * (10.0).pow(fractionDigits)).round().toInt();
+  String toStringAsPrecision(int precision) {
+    // See ECMAScript-262, 15.7.4.7 for details.
 
-      // Step 8.b.
-      m = n.toString();
+    // The EcmaScript specification checks for NaN and Infinity before looking
+    // at the fractionDigits. In Dart we are consistent with toStringAsFixed and
+    // look at the fractionDigits first.
 
-      // Step 8.c.
-      if (fractionDigits != 0) {
-        // Step 8.c.i.
-        int k = m.length;
-        // Step 8.c.ii.
-        if (k <= fractionDigits) {
-          StringBuffer sb = new StringBuffer();
-          for (int i = 0; i < fractionDigits + 1 - k; i++) {
-            sb.add("0");
-          }
-          String z = sb.toString();
-          m = z + m;
-          k = fractionDigits + 1;
-        }
-        // Step 8.c.iii.
-        String a = m.substring(0, k - fractionDigits);
-        String b = m.substring(k - fractionDigits);
-        // Step 8.c.iv.
-        m = a + "." + b;
-      }
+    // Step 8.
+    if (precision < 1 || precision > 21) {
+      // TODO(antonm): should be proper RangeError or Dart counterpart.
+      throw "Range error";
     }
 
-    // Step 9.
-    return s + m;
+    return _toStringAsPrecision(precision);
   }
-  String toStringAsExponential(int fractionDigits) {
-    throw "Double.toStringAsExponential unimplemented.";
-  }
-  String toStringAsPrecision(int precision) {
-    throw "Double.toStringAsPrecision unimplemented.";
-  }
+  String _toStringAsPrecision(int fractionDigits)
+      native "Double_toStringAsPrecision";
+
   String toRadixString(int radix) {
     throw "Double.toRadixString unimplemented.";
   }
 
   // Order is: NaN > Infinity > ... > 0.0 > -0.0 > ... > -Infinity.
   int compareTo(Comparable other) {
     final int EQUAL = 0, LESS = -1, GREATER = 1;
     if (this < other) {
       return LESS;
     } else if (this > other) {
@@ skipping 10 matching lines @@
         return EQUAL;
       }
     } else if (isNaN()) {
       return other.isNaN() ? EQUAL : GREATER;
     } else {
       // Other is NaN.
       return LESS;
     }
   }
 }