Rewrite double.parse.

sdk/lib/core/double.dart

 // Copyright (c) 2012, 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.
 
 part of dart.core;
 
 // TODO: Convert this abstract class into a concrete class double
 // that uses the patch class functionality to account for the
 // different platform implementations.
 
@@ skipping 115 matching lines @@
    * Returns "-0.0" for negative zero.
    *
    * It should always be the case that if [:d:] is a [double], then
    * [:d == double.parse(d.toString()):].
    */
   String toString();
 
   /**
    * Parse [source] as an double literal and return its value.
    *
-   * Accepts the same format as double literals:
-   *   [: ['+'|'-'] [digit* '.'] digit+ [('e'|'E') ['+'|'-'] digit+] :]
+   * Accepts the following format:
+   * `/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$`.

[Lasse Reichstein Nielsen, 2013/05/21 06:12:09]

Don't use RegExp as specification. It's unreadable to the common user (and
(P-space) hard to read for those who do can read regexps).

I don't want to accept leading or trailing whitespace. The user can remove it
using String.trim if necessary - no need to also implement trim in this
function. It seems the previous implementations accepted it though, so we might
need to keep it for consistency.

Also accepts "4." which is not a valid literal (and wasn't allowed before).
Please disallow this.

Is +4 a valid literal in the spec any more? (Both implementations accept it, but
I seem to remember it being removed).

[floitsch, 2013/05/21 14:39:31]

Removed the regexp.
As discussed keeping the new behavior.

    *
-   * Also recognizes "NaN", "Infinity" and "-Infinity" as inputs and
-   * returns the corresponding double value.
+   * In English this equals an optional sign followed by either, "Infinity",
+   * "NaN" or a double number. A double number is composed of the mantissa and

[Lasse Reichstein Nielsen, 2013/05/21 06:12:09]

This accepts -NaN, which is meaningless. Please avoid that as well.

[floitsch, 2013/05/21 14:39:31]

As discussed. keeping.

+   * and optional exponent part. The mantissa is either a dot followed by a
+   * sequence of digits, or a sequence of digits optionally followed by a dot
+   * and more digits. The (optional) exponent part consists of the character
+   * "e" or "E", an optional sign, and the exponent digits.
    *
-   * If the [soure] is not a valid double literal, the [handleError]
+   * The whole double may be surrounded by whitespace.
+   *
+   * If the [source] is not a valid double literal, the [handleError]
    * is called with the [source] as argument, and its return value is
    * used instead. If no handleError is provided, a [FormatException]
    * is thrown.
+   *
+   * Examples of accepted strings:
+   *
+   *     "3.14"
+   *     "  3.14 \xA0"
+   *     "0."
+   *     ".0"
+   *     "-1.e3"
+   *     "1234E+7"
+   *     "+.12e-9"
+   *     "-NaN"
    */
   external static double parse(String source,
                                [double handleError(String source)]);
 }