Changeset 65959 in webkit for trunk/JavaScriptCore/wtf/dtoa.cpp

Timestamp:

Aug 24, 2010, 6:04:31 PM (15 years ago)

Author:

[email protected]

Message:

JavaScriptCore: ​https://bugs.webkit.org/show_bug.cgi?id=44487

Reviewed by Oliver Hunt.

Number.toExponential/toFixed/toPrecision all contain a spaghetti of duplicated
code & unnecessary complexity. Add a new DecimalNumber class to encapsulate
double to string conversion, share the implementations of rounding &
decimal-fraction/exponential formatting.

• JavaScriptCore.exp:

Update exports.

• runtime/NumberPrototype.cpp:

(JSC::toThisNumber):
(JSC::getIntegerArgumentInRange):

Helper methods used in implementing toExponential/toFixed/toString.

(JSC::numberProtoFuncToExponential):
(JSC::numberProtoFuncToFixed):
(JSC::numberProtoFuncToPrecision):

Reimplemented using new DecimalNumber class.

• runtime/UString.cpp:

(JSC::UString::number):

Updated to call numberToString.

• wtf/DecimalNumber.h: Added.

(WTF::):
(WTF::DecimalNumber::DecimalNumber):
(WTF::DecimalNumber::toStringDecimal):
(WTF::DecimalNumber::toStringExponential):
(WTF::DecimalNumber::sign):
(WTF::DecimalNumber::exponent):
(WTF::DecimalNumber::significand):
(WTF::DecimalNumber::precision):
(WTF::DecimalNumber::init):
(WTF::DecimalNumber::isZero):
(WTF::DecimalNumber::roundToPrecision):

New class to perform double to string conversion.
Has three constructors, which allow conversion with no rounding,
rounding to significant-figures, or rounding to decimal-places,
and two methods for formatting strings, either using decimal
fraction or exponential encoding. Internal implementation uses
pre-rounding of the values before calling dtoa rather than
relying on dtoa to correctly round, which does not produce
fully accurate results. Hopefully we can address this in the
near future.

• wtf/dtoa.cpp:

(WTF::intPow10):

• wtf/dtoa.h:

intPow10 is used internally by DecimalNumber.

• wtf/text/WTFString.cpp:

(WTF::copyToString):
(WTF::nanOrInfToString):

Used internally in numberToString for NaN/Infinity handling.

(WTF::numberToString):

Added new method to convert doubles to strings.

• wtf/text/WTFString.h:

Added declaration for numberToString. This is here because
we should switch over to using this for all double to string
conversion in WebCore (see section 2.4.4.3 of the HTML5 spec).

JavaScriptGlue: ​https://bugs.webkit.org/show_bug.cgi?id=44487

Reviewed by Oliver Hunt.

• ForwardingHeaders/wtf/text/WTFString.h: Added.

WebCore: ​https://bugs.webkit.org/show_bug.cgi?id=44487

Reviewed by Oliver Hunt.

• html/LegacyHTMLTreeBuilder.cpp:

(WebCore::serializeForNumberType):

Update function call to numberToString.

LayoutTests: Bug 44487 - Clean up NumberPrototype.cpp

Reviewed by Oliver Hunt.

This patch changes some layout test results - in all these cases we were
not previously accurate to spec defined behaviour, and we are still not

• but overall this changes reduces the overall magnitude of error due to

rounding differences. The underlying problem is that we should be using
dtoa to generate results to a specified accuracy, rather than relying on
pre-rounding the input values. We should look at reenabling our dtoa
implementation to work in this fashion as a separate change.

• fast/js/kde/Number-expected.txt:
• fast/js/kde/script-tests/Number.js:
• fast/js/number-toExponential-expected.txt:
• fast/js/number-tofixed-expected.txt:
• fast/js/number-toprecision-expected.txt:
• fast/js/script-tests/number-toExponential.js:
• fast/js/script-tests/number-tofixed.js:
• fast/js/script-tests/number-toprecision.js:

File:

• trunk/JavaScriptCore/wtf/dtoa.cpp (modified) (1 diff)

trunk/JavaScriptCore/wtf/dtoa.cpp

@@ -2286 +2286 @@
 }
 
-static ALWAYS_INLINE void append(char*& next, const char* src, unsigned size)
+double intPow10(int e)
 {
-    for (unsigned i = 0; i < size; ++i)
-        *next++ = *src++;
+    // This function uses the "exponentiation by squaring" algorithm and
+    // long double to quickly and precisely calculate integer powers of 10.0.
+
+    // This is a handy workaround for <rdar://problem/4494756>
+
+    if (!e)
+        return 1.0;
+
+    bool negative = e < 0;
+    unsigned exp = negative ? -e : e;
+
+    long double result = 10.0;
+    bool foundOne = false;
+    for (int bit = 31; bit >= 0; bit--) {
+        if (!foundOne) {
+            if ((exp >> bit) & 1)
+                foundOne = true;
+        } else {
+            result = result * result;
+            if ((exp >> bit) & 1)
+                result = result * 10.0;
+        }
+    }
+
+    if (negative)
+        return static_cast<double>(1.0 / result);
+    return static_cast<double>(result);
 }
 
-void doubleToStringInJavaScriptFormat(double d, DtoaBuffer buffer, unsigned* resultLength)
-{
-    ASSERT(buffer);
-
-    // avoid ever printing -NaN, in JS conceptually there is only one NaN value
-    if (isnan(d)) {
-        append(buffer, "NaN", 3);
-        if (resultLength)
-            *resultLength = 3;
-        return;
-    }
-    // -0 -> "0"
-    if (!d) {
-        buffer[0] = '0';
-        if (resultLength)
-            *resultLength = 1;
-        return;
-    }
-
-    int decimalPoint;
-    int sign;
-
-    DtoaBuffer result;
-    char* resultEnd = 0;
-    WTF::dtoa(result, d, 0, &decimalPoint, &sign, &resultEnd);
-    int length = resultEnd - result;
-
-    char* next = buffer;
-    if (sign)
-        *next++ = '-';
-
-    if (decimalPoint <= 0 && decimalPoint > -6) {
-        *next++ = '0';
-        *next++ = '.';
-        for (int j = decimalPoint; j < 0; j++)
-            *next++ = '0';
-        append(next, result, length);
-    } else if (decimalPoint <= 21 && decimalPoint > 0) {
-        if (length <= decimalPoint) {
-            append(next, result, length);
-            for (int j = 0; j < decimalPoint - length; j++)
-                *next++ = '0';
-        } else {
-            append(next, result, decimalPoint);
-            *next++ = '.';
-            append(next, result + decimalPoint, length - decimalPoint);
-        }
-    } else if (result[0] < '0' || result[0] > '9')
-        append(next, result, length);
-    else {
-        *next++ = result[0];
-        if (length > 1) {
-            *next++ = '.';
-            append(next, result + 1, length - 1);
-        }
-
-        *next++ = 'e';
-        *next++ = (decimalPoint >= 0) ? '+' : '-';
-        // decimalPoint can't be more than 3 digits decimal given the
-        // nature of float representation
-        int exponential = decimalPoint - 1;
-        if (exponential < 0)
-            exponential = -exponential;
-        if (exponential >= 100)
-            *next++ = static_cast<char>('0' + exponential / 100);
-        if (exponential >= 10)
-            *next++ = static_cast<char>('0' + (exponential % 100) / 10);
-        *next++ = static_cast<char>('0' + exponential % 10);
-    }
-    if (resultLength)
-        *resultLength = next - buffer;
-}
-
 } // namespace WTF