Changeset 67825 in webkit for trunk/JavaScriptCore/runtime/JSValue.h

Timestamp:

Sep 19, 2010, 6:23:33 PM (15 years ago)

Author:

[email protected]

Message:

Bug 46065 - Unify implementation of ToInt32 and ToUInt32, don't use fmod.

Reviewed by Oliver Hunt.

These methods implement the same conversion (see discussion in the notes
of sections of 9.5 and 9.6 of the spec), only differing in how the result
is interpretted.

JavaScriptCore:

Date prototype is incorrectly using toInt32, and this is causing us to
provide an output value indicating whether the input to ToInt32 was finite
(the corresponding methods on Date are actually spec'ed to use ToInteger,
not ToInt32). This patch partially fixes this in order to remove this
bogus output value, hoewever more work will be require to bring Date
fully up to spec compliance (the constructor is still performing ToInt32
conversions).

• JavaScriptCore.exp:
• runtime/DatePrototype.cpp:

(JSC::fillStructuresUsingTimeArgs):
(JSC::fillStructuresUsingDateArgs):
(JSC::dateProtoFuncSetYear):

• runtime/JSValue.cpp:

(JSC::toInt32):

• runtime/JSValue.h:

(JSC::toUInt32):
(JSC::JSValue::toInt32):
(JSC::JSValue::toUInt32):

WebCore:

Removing JSValue::toInt32 (since this has weird, non-spec function).
A couple of places in the binding are using this method, so adding
finiteInt32Value to the bindings to maintain current behaviour.

Test: fast/js/toInt32UInt32.html

• bindings/js/JSDOMBinding.h:

(WebCore::finiteInt32Value):

• bindings/js/JSHTMLOptionsCollectionCustom.cpp:

(WebCore::JSHTMLOptionsCollection::add):

• bindings/js/JSSQLResultSetRowListCustom.cpp:

(WebCore::JSSQLResultSetRowList::item):

• bindings/js/JSSVGPODListCustom.h:

(WebCore::JSSVGPODListCustom::getItem):
(WebCore::JSSVGPODListCustom::insertItemBefore):
(WebCore::JSSVGPODListCustom::replaceItem):
(WebCore::JSSVGPODListCustom::removeItem):

• bindings/js/JSSVGPathSegListCustom.cpp:

(WebCore::JSSVGPathSegList::getItem):
(WebCore::JSSVGPathSegList::insertItemBefore):
(WebCore::JSSVGPathSegList::replaceItem):
(WebCore::JSSVGPathSegList::removeItem):

LayoutTests:

Add test cases for ToInt32 / ToUInt32 functionality.

• fast/js/script-tests/toInt32UInt32.js: Added.
• fast/js/toInt32UInt32-expected.txt: Added.
• fast/js/toInt32UInt32.html: Added.

File:

• trunk/JavaScriptCore/runtime/JSValue.h (modified) (4 diffs)

trunk/JavaScriptCore/runtime/JSValue.h

@@ -57 +57 @@
 
     double nonInlineNaN();
-    int32_t toInt32SlowCase(double, bool& ok);
-    uint32_t toUInt32SlowCase(double, bool& ok);
+
+    // This implements ToInt32, defined in ECMA-262 9.5.
+    int32_t toInt32(double);
+
+    // This implements ToUInt32, defined in ECMA-262 9.6.
+    inline uint32_t toUInt32(double number)
+    {
+        // As commented in the spec, the operation of ToInt32 and ToUint32 only differ
+        // in how the result is interpreted; see NOTEs in sections 9.5 and 9.6.
+        return toInt32(number);
+    }
 
     class JSValue {
@@ -164 +173 @@
         double toIntegerPreserveNaN(ExecState*) const;
         int32_t toInt32(ExecState*) const;
-        int32_t toInt32(ExecState*, bool& ok) const;
         uint32_t toUInt32(ExecState*) const;
-        uint32_t toUInt32(ExecState*, bool& ok) const;
 
 #if ENABLE(JSC_ZOMBIES)
@@ -368 +375 @@
     inline bool operator!=(const JSCell* a, const JSValue b) { return JSValue(a) != b; }
 
-    inline int32_t toInt32(double val)
-    {
-        if (!(val >= -2147483648.0 && val < 2147483648.0)) {
-            bool ignored;
-            return toInt32SlowCase(val, ignored);
-        }
-        return static_cast<int32_t>(val);
-    }
-
-    inline uint32_t toUInt32(double val)
-    {
-        if (!(val >= 0.0 && val < 4294967296.0)) {
-            bool ignored;
-            return toUInt32SlowCase(val, ignored);
-        }
-        return static_cast<uint32_t>(val);
-    }
-
     // FIXME: We should deprecate this and just use JSValue::asCell() instead.
     JSCell* asCell(JSValue);
@@ -398 +387 @@
         if (isInt32())
             return asInt32();
-
-        double val = toNumber(exec);
-
-        if (val >= -2147483648.0 && val < 2147483648.0)
-            return static_cast<int32_t>(val);
-
-        bool ignored;
-        return toInt32SlowCase(val, ignored);
+        return JSC::toInt32(toNumber(exec));
     }
 
     inline uint32_t JSValue::toUInt32(ExecState* exec) const
     {
-        if (isUInt32())
-            return asUInt32();
-
-        double val = toNumber(exec);
-
-        if (val >= 0.0 && val < 4294967296.0)
-            return static_cast<uint32_t>(val);
-
-        bool ignored;
-        return toUInt32SlowCase(val, ignored);
-    }
-
-    inline int32_t JSValue::toInt32(ExecState* exec, bool& ok) const
-    {
-        if (isInt32()) {
-            ok = true;
-            return asInt32();
-        }
-
-        double val = toNumber(exec);
-
-        if (val >= -2147483648.0 && val < 2147483648.0) {
-            ok = true;
-            return static_cast<int32_t>(val);
-        }
-
-        return toInt32SlowCase(val, ok);
-    }
-
-    inline uint32_t JSValue::toUInt32(ExecState* exec, bool& ok) const
-    {
-        if (isUInt32()) {
-            ok = true;
-            return asInt32();
-        }
-
-        double val = toNumber(exec);
-
-        if (val >= 0.0 && val < 4294967296.0) {
-            ok = true;
-            return static_cast<uint32_t>(val);
-        }
-
-        return toUInt32SlowCase(val, ok);
+        // See comment on JSC::toUInt32, above.
+        return toInt32(exec);
     }