Changeset 65588 in webkit for trunk/JavaScriptCore/runtime/UString.cpp

Timestamp:

Aug 18, 2010, 12:41:22 AM (15 years ago)

Author:

[email protected]

Message:

Bug 44146 - Remove toDouble/toUInt32 methods from UString.

Reviewed by Sam Weinig.

JavaScriptCore:

These methods all implement JavaScript language specific behaviour, and as such
are not suited to being on a generic string object. They are also inefficient
and incorrectly used, refactor & cleanup. Uses of these methods really divide
out into two cases.

ToNumber:
Uses of toDouble from JSString and from parseFloat are implementing ecma's
ToNumber conversion from strings (see ecma-262 9.3.1), so UString::toDouble
should largely just be moved out to a global jsToNumber function. ToNumber is
capable of recognizing either decimal or hexadecimal numbers, but parseFloat
should only recognize decimal values. This is currently handled by testing for
hexadecimal before calling toDouble, which should unnecessary - instead we can
just split out the two parts to the grammar into separate functions. Also,
strtod recognizes a set of literals (nan, inf, and infinity - all with any
capitalization) - which are not defined by any of the specs we are implementing.
To handle this we need to perform additional work in toDouble to convert the
unsupported cases of infinities back to NaNs. Instead we should simply remove
support for this literals from strtod. This should provide a more desirable
behaviour for all clients of strtod.

Indexed properties:
Uses of the toStrictUInt32 methods are were all converting property names to
indices, and all uses of toUInt32 were incorrect; in all cases we should have
been calling toUInt32. This error results in some incorrect behaviour in the
DOM (accessing property "0 " of a NodeList should fail; it currently does not).
Move this method onto Identifier (our canonical property name), and make it
always perform a strict conversion. Add a layout test to check NodeList does
convert indexed property names correctly.

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

(JSC::Arguments::getOwnPropertySlot):
(JSC::Arguments::getOwnPropertyDescriptor):
(JSC::Arguments::put):
(JSC::Arguments::deleteProperty):

• runtime/Identifier.cpp:

(JSC::Identifier::toUInt32):

• runtime/Identifier.h:

(JSC::Identifier::toUInt32):

• runtime/JSArray.cpp:

(JSC::JSArray::getOwnPropertySlot):
(JSC::JSArray::getOwnPropertyDescriptor):
(JSC::JSArray::put):
(JSC::JSArray::deleteProperty):

• runtime/JSArray.h:

(JSC::Identifier::toArrayIndex):

• runtime/JSByteArray.cpp:

(JSC::JSByteArray::getOwnPropertySlot):
(JSC::JSByteArray::getOwnPropertyDescriptor):
(JSC::JSByteArray::put):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::isInfinity):
(JSC::jsHexIntegerLiteral):
(JSC::jsStrDecimalLiteral):
(JSC::jsToNumber):
(JSC::parseFloat):

• runtime/JSGlobalObjectFunctions.h:
• runtime/JSString.cpp:

(JSC::JSString::getPrimitiveNumber):
(JSC::JSString::toNumber):
(JSC::JSString::getStringPropertyDescriptor):

• runtime/JSString.h:

(JSC::JSString::getStringPropertySlot):

• runtime/ObjectPrototype.cpp:

(JSC::ObjectPrototype::put):

• runtime/StringObject.cpp:

(JSC::StringObject::deleteProperty):

• runtime/UString.cpp:
• runtime/UString.h:
• wtf/dtoa.cpp:

(WTF::strtod):

WebCore:

These methods all implement JavaScript language specific behaviour, and as such
are not suited to being on a generic string object. They are also inefficient
and incorrectly used, refactor & cleanup. Uses of these methods really divide
out into two cases.

ToNumber:
Uses of toDouble from JSString and from parseFloat are implementing ecma's
ToNumber conversion from strings (see ecma-262 9.3.1), so UString::toDouble
should largely just be moved out to a global jsToNumber function. ToNumber is
capable of recognizing either decimal or hexadecimal numbers, but parseFloat
should only recognize decimal values. This is currently handled by testing for
hexadecimal before calling toDouble, which should unnecessary - instead we can
just split out the two parts to the grammar into separate functions. Also,
strtod recognizes a set of literals (nan, inf, and infinity - all with any
capitalization) - which are not defined by any of the specs we are implementing.
To handle this we need to perform additional work in toDouble to convert the
unsupported cases of infinities back to NaNs. Instead we should simply remove
support for this literals from strtod. This should provide a more desirable
behaviour for all clients of strtod.

Indexed properties:
Uses of the toStrictUInt32 methods are were all converting property names to
indices, and all uses of toUInt32 were incorrect; in all cases we should have
been calling toUInt32. This error results in some incorrect behaviour in the
DOM (accessing property "0 " of a NodeList should fail; it currently does not).
Move this method onto Identifier (our canonical property name), and make it
always perform a strict conversion. Add a layout test to check NodeList does
convert indexed property names correctly.

Test: fast/dom/NodeList/nodelist-item-with-index.html

• WebCore.xcodeproj/project.pbxproj:
• bindings/js/JSDOMWindowCustom.cpp:

(WebCore::JSDOMWindow::getOwnPropertySlot):
(WebCore::JSDOMWindow::getOwnPropertyDescriptor):

• bindings/js/JSHTMLAllCollectionCustom.cpp:

(WebCore::callHTMLAllCollection):
(WebCore::JSHTMLAllCollection::item):

• bindings/js/JSHTMLCollectionCustom.cpp:

(WebCore::callHTMLCollection):
(WebCore::JSHTMLCollection::item):

• bindings/js/JSNodeListCustom.cpp:

(WebCore::callNodeList):

• bindings/scripts/CodeGeneratorJS.pm:
• bridge/runtime_array.cpp:

(JSC::RuntimeArray::getOwnPropertySlot):
(JSC::RuntimeArray::getOwnPropertyDescriptor):
(JSC::RuntimeArray::put):

LayoutTests:

Test that indexing into nodelists works correctly, particularly
wrt indices passed as strings that contain whitespace.

• fast/dom/NodeList/nodelist-item-with-index-expected.txt: Added.
• fast/dom/NodeList/nodelist-item-with-index.html: Added.

File:

• trunk/JavaScriptCore/runtime/UString.cpp (modified) (1 diff)

trunk/JavaScriptCore/runtime/UString.cpp

@@ -205 +205 @@
 }
 
-static inline bool isInfinity(double number)
-{
-    return number == Inf || number == -Inf;
-}
-
-static bool isInfinity(const UChar* data, const UChar* end)
-{
-    return data + 7 < end
-        && data[0] == 'I'
-        && data[1] == 'n'
-        && data[2] == 'f'
-        && data[3] == 'i'
-        && data[4] == 'n'
-        && data[5] == 'i'
-        && data[6] == 't'
-        && data[7] == 'y';
-}
-
-double UString::toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const
-{
-    unsigned size = this->length();
-
-    if (size == 1) {
-        UChar c = characters()[0];
-        if (isASCIIDigit(c))
-            return c - '0';
-        if (isStrWhiteSpace(c) && tolerateEmptyString)
-            return 0;
-        return NaN;
-    }
-
-    const UChar* data = this->characters();
-    const UChar* end = data + size;
-
-    // Skip leading white space.
-    for (; data < end; ++data) {
-        if (!isStrWhiteSpace(*data))
-            break;
-    }
-
-    // Empty string.
-    if (data == end)
-        return tolerateEmptyString ? 0.0 : NaN;
-
-    double number;
-
-    if (data[0] == '0' && data + 2 < end && (data[1] | 0x20) == 'x' && isASCIIHexDigit(data[2])) {
-        // Hex number.
-        data += 2;
-        const UChar* firstDigitPosition = data;
-        number = 0;
-        while (true) {
-            number = number * 16 + toASCIIHexValue(*data);
-            ++data;
-            if (data == end)
-                break;
-            if (!isASCIIHexDigit(*data))
-                break;
-        }
-        if (number >= mantissaOverflowLowerBound)
-            number = parseIntOverflow(firstDigitPosition, data - firstDigitPosition, 16);
-    } else {
-        // Decimal number.
-
-        // Put into a null-terminated byte buffer.
-        Vector<char, 32> byteBuffer;
-        for (const UChar* characters = data; characters < end; ++characters) {
-            UChar character = *characters;
-            byteBuffer.append(isASCII(character) ? character : 0);
-        }
-        byteBuffer.append(0);
-
-        char* byteBufferEnd;
-        number = WTF::strtod(byteBuffer.data(), &byteBufferEnd);
-        const UChar* pastNumber = data + (byteBufferEnd - byteBuffer.data());
-
-        if ((number || pastNumber != data) && !isInfinity(number))
-            data = pastNumber;
-        else {
-            // We used strtod() to do the conversion. However, strtod() handles
-            // infinite values slightly differently than JavaScript in that it
-            // converts the string "inf" with any capitalization to infinity,
-            // whereas the ECMA spec requires that it be converted to NaN.
-
-            double signedInfinity = Inf;
-            if (data < end) {
-                if (*data == '+')
-                    data++;
-                else if (*data == '-') {
-                    signedInfinity = -Inf;
-                    data++;
-                }
-            }
-            if (isInfinity(data, end)) {
-                number = signedInfinity;
-                data += 8;
-            } else if (isInfinity(number) && data < end && (*data | 0x20) != 'i')
-                data = pastNumber;
-            else
-                return NaN;
-        }
-    }
-
-    // Look for trailing junk.
-    if (!tolerateTrailingJunk) {
-        // Allow trailing white space.
-        for (; data < end; ++data) {
-            if (!isStrWhiteSpace(*data))
-                break;
-        }
-        if (data != end)
-            return NaN;
-    }
-
-    return number;
-}
-
-double UString::toDouble(bool tolerateTrailingJunk) const
-{
-    return toDouble(tolerateTrailingJunk, true);
-}
-
-double UString::toDouble() const
-{
-    return toDouble(false, true);
-}
-
-uint32_t UString::toUInt32(bool* ok) const
-{
-    double d = toDouble();
-    bool b = true;
-
-    if (d != static_cast<uint32_t>(d)) {
-        b = false;
-        d = 0;
-    }
-
-    if (ok)
-        *ok = b;
-
-    return static_cast<uint32_t>(d);
-}
-
-uint32_t UString::toUInt32(bool* ok, bool tolerateEmptyString) const
-{
-    double d = toDouble(false, tolerateEmptyString);
-    bool b = true;
-
-    if (d != static_cast<uint32_t>(d)) {
-        b = false;
-        d = 0;
-    }
-
-    if (ok)
-        *ok = b;
-
-    return static_cast<uint32_t>(d);
-}
-
-uint32_t UString::toStrictUInt32(bool* ok) const
-{
-    if (ok)
-        *ok = false;
-
-    // Empty string is not OK.
-    unsigned len = m_impl->length();
-    if (len == 0)
-        return 0;
-    const UChar* p = m_impl->characters();
-    unsigned short c = p[0];
-
-    // If the first digit is 0, only 0 itself is OK.
-    if (c == '0') {
-        if (len == 1 && ok)
-            *ok = true;
-        return 0;
-    }
-
-    // Convert to UInt32, checking for overflow.
-    uint32_t i = 0;
-    while (1) {
-        // Process character, turning it into a digit.
-        if (c < '0' || c > '9')
-            return 0;
-        const unsigned d = c - '0';
-
-        // Multiply by 10, checking for overflow out of 32 bits.
-        if (i > 0xFFFFFFFFU / 10)
-            return 0;
-        i *= 10;
-
-        // Add in the digit, checking for overflow out of 32 bits.
-        const unsigned max = 0xFFFFFFFFU - d;
-        if (i > max)
-            return 0;
-        i += d;
-
-        // Handle end of string.
-        if (--len == 0) {
-            if (ok)
-                *ok = true;
-            return i;
-        }
-
-        // Get next character.
-        c = *(++p);
-    }
-}
-
 UString UString::substr(unsigned pos, unsigned len) const
 {