Reviewed by Darin Adler.
authorweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 17 Feb 2008 03:43:01 +0000 (03:43 +0000)
committerweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 17 Feb 2008 03:43:01 +0000 (03:43 +0000)
        Take another step in the direction of getting rid of DeprecatedString
        by moving all the to{NumericType} off of it.

        - Create free functions that take a UChar* buffer and length to do
          the string-to-number conversions.  This allows us to avoid two allocations
          if we don't already have a String and is consistent with the design we would
          like going forward.
        - Since the toInt (and family) functions on DeprecatedString were slightly
          different than the ones on String (they didn't allow trailing garbage),
          an extra set of 'Strict' toInt functions were added that have this behavior.

        * platform/graphics/Color.cpp:
        (WebCore::Color::parseHexColor):
        * platform/text/PlatformString.h:
        * platform/text/String.cpp:
        (WebCore::String::percentage):
        (WebCore::String::toIntStrict):
        (WebCore::String::toUIntStrict):
        (WebCore::String::toInt64Strict):
        (WebCore::String::toUInt64Strict):
        (WebCore::String::toUInt):
        (WebCore::String::toDouble):
        (WebCore::isCharacterAllowedInBase):
        (WebCore::toIntegralType):
        (WebCore::lengthOfCharactersAsInteger):
        (WebCore::charactersToIntStrict):
        (WebCore::charactersToUIntStrict):
        (WebCore::charactersToInt64Strict):
        (WebCore::charactersToUInt64Strict):
        (WebCore::charactersToInt):
        (WebCore::charactersToUInt):
        (WebCore::charactersToInt64):
        (WebCore::charactersToUInt64):
        (WebCore::charactersToDouble):
        (WebCore::charactersToFloat):
        * platform/text/StringImpl.cpp:
        (WebCore::parseLength):
        (WebCore::StringImpl::toIntStrict):
        (WebCore::StringImpl::toUIntStrict):
        (WebCore::StringImpl::toInt64Strict):
        (WebCore::StringImpl::toUInt64Strict):
        (WebCore::StringImpl::toInt):
        (WebCore::StringImpl::toUInt):
        (WebCore::StringImpl::toInt64):
        (WebCore::StringImpl::toUInt64):
        (WebCore::StringImpl::toDouble):
        (WebCore::StringImpl::toFloat):
        * platform/text/StringImpl.h:
        * svg/SVGAnimationElement.cpp:
        (WebCore::SVGAnimationElement::parseClockValue):
        * svg/SVGFETurbulenceElement.cpp:
        (WebCore::SVGFETurbulenceElement::parseMappedAttribute):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@30343 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebCore/ChangeLog
WebCore/platform/graphics/Color.cpp
WebCore/platform/text/PlatformString.h
WebCore/platform/text/String.cpp
WebCore/platform/text/StringImpl.cpp
WebCore/platform/text/StringImpl.h
WebCore/svg/SVGAnimationElement.cpp
WebCore/svg/SVGFETurbulenceElement.cpp

index 2bad341..29b1c37 100644 (file)
@@ -1,3 +1,60 @@
+2008-02-16  Sam Weinig  <sam@webkit.org>
+
+        Reviewed by Darin Adler.
+
+        Take another step in the direction of getting rid of DeprecatedString
+        by moving all the to{NumericType} off of it.
+
+        - Create free functions that take a UChar* buffer and length to do
+          the string-to-number conversions.  This allows us to avoid two allocations
+          if we don't already have a String and is consistent with the design we would
+          like going forward.
+        - Since the toInt (and family) functions on DeprecatedString were slightly
+          different than the ones on String (they didn't allow trailing garbage),
+          an extra set of 'Strict' toInt functions were added that have this behavior.
+
+        * platform/graphics/Color.cpp:
+        (WebCore::Color::parseHexColor):
+        * platform/text/PlatformString.h:
+        * platform/text/String.cpp:
+        (WebCore::String::percentage):
+        (WebCore::String::toIntStrict):
+        (WebCore::String::toUIntStrict):
+        (WebCore::String::toInt64Strict):
+        (WebCore::String::toUInt64Strict):
+        (WebCore::String::toUInt):
+        (WebCore::String::toDouble):
+        (WebCore::isCharacterAllowedInBase):
+        (WebCore::toIntegralType):
+        (WebCore::lengthOfCharactersAsInteger):
+        (WebCore::charactersToIntStrict):
+        (WebCore::charactersToUIntStrict):
+        (WebCore::charactersToInt64Strict):
+        (WebCore::charactersToUInt64Strict):
+        (WebCore::charactersToInt):
+        (WebCore::charactersToUInt):
+        (WebCore::charactersToInt64):
+        (WebCore::charactersToUInt64):
+        (WebCore::charactersToDouble):
+        (WebCore::charactersToFloat):
+        * platform/text/StringImpl.cpp:
+        (WebCore::parseLength):
+        (WebCore::StringImpl::toIntStrict):
+        (WebCore::StringImpl::toUIntStrict):
+        (WebCore::StringImpl::toInt64Strict):
+        (WebCore::StringImpl::toUInt64Strict):
+        (WebCore::StringImpl::toInt):
+        (WebCore::StringImpl::toUInt):
+        (WebCore::StringImpl::toInt64):
+        (WebCore::StringImpl::toUInt64):
+        (WebCore::StringImpl::toDouble):
+        (WebCore::StringImpl::toFloat):
+        * platform/text/StringImpl.h:
+        * svg/SVGAnimationElement.cpp:
+        (WebCore::SVGAnimationElement::parseClockValue):
+        * svg/SVGFETurbulenceElement.cpp:
+        (WebCore::SVGFETurbulenceElement::parseMappedAttribute):
+
 2008-02-16  Dan Bernstein  <mitz@apple.com>
 
         Reviewed by Sam Weinig.
index b0efff1..47fc923 100644 (file)
@@ -95,7 +95,7 @@ bool Color::parseHexColor(const String& name, RGBA32& rgb)
     int len = name.length();
     if (len == 3 || len == 6) {
         bool ok;
-        int val = name.deprecatedString().toInt(&ok, 16);
+        int val = name.toIntStrict(&ok, 16);
         if (ok) {
             if (len == 6) {
                 rgb = 0xFF000000 | val;
index 973e519..1b52146 100644 (file)
@@ -137,14 +137,20 @@ public:
     void split(UChar separator, Vector<String>& result) const;
     void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
 
+    int toIntStrict(bool* ok = 0, int base = 10) const;
+    unsigned toUIntStrict(bool* ok = 0, int base = 10) const;
+    int64_t toInt64Strict(bool* ok = 0, int base = 10) const;
+    uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const;
+
     int toInt(bool* ok = 0) const;
+    unsigned toUInt(bool* ok = 0) const;
     int64_t toInt64(bool* ok = 0) const;
     uint64_t toUInt64(bool* ok = 0) const;
     double toDouble(bool* ok = 0) const;
     float toFloat(bool* ok = 0) const;
     Length* toLengthArray(int& len) const;
     Length* toCoordsArray(int& len) const;
-    bool percentage(int &_percentage) const;
+    bool percentage(intpercentage) const;
 
     // Makes a deep copy. Helpful only if you need to use a String on another thread.
     // Since the underlying StringImpl objects are immutable, there's no other reason
@@ -231,8 +237,24 @@ inline bool operator!=(const DeprecatedString& b, const String& a ) { return !(a
 
 inline bool operator!(const String& str) { return str.isNull(); }
 
+
+// String Operations
+
 bool charactersAreAllASCII(const UChar*, size_t);
 
+int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
+unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
+int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
+uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
+
+int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
+unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
+int64_t charactersToInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
+uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
+
+double charactersToDouble(const UChar*, size_t, bool* ok = 0);
+float charactersToFloat(const UChar*, size_t, bool* ok = 0);
+
 void append(Vector<UChar>&, const String&);
 
 #ifdef __OBJC__
index 98ba336..d801047 100644 (file)
 
 #include "CString.h"
 #include "DeprecatedString.h"
+#include "FloatConversion.h"
 #include "StringBuffer.h"
 #include "TextEncoding.h"
+#include <kjs/dtoa.h>
 #include <kjs/identifier.h>
+#include <limits>
+#include <stdarg.h>
+#include <wtf/ASCIICType.h>
 #include <wtf/StringExtras.h>
 #include <wtf/Vector.h>
-#include <stdarg.h>
+#include <wtf/unicode/Unicode.h>
 
 using KJS::Identifier;
 using KJS::UString;
 
+using namespace WTF;
+
 namespace WebCore {
 
 String::String(const UChar* str, unsigned len)
@@ -289,7 +296,7 @@ bool String::percentage(int& result) const
     if ((*m_impl)[m_impl->length() - 1] != '%')
        return false;
 
-    result = DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_impl->characters()), m_impl->length() - 1).string().toInt();
+    result = charactersToIntStrict(m_impl->characters(), m_impl->length() - 1);
     return true;
 }
 
@@ -400,6 +407,46 @@ String String::number(double n)
     return String::format("%.6lg", n);
 }
 
+int String::toIntStrict(bool* ok, int base) const
+{
+    if (!m_impl) {
+        if (ok)
+            *ok = false;
+        return 0;
+    }
+    return m_impl->toIntStrict(ok, base);
+}
+
+unsigned String::toUIntStrict(bool* ok, int base) const
+{
+    if (!m_impl) {
+        if (ok)
+            *ok = false;
+        return 0;
+    }
+    return m_impl->toUIntStrict(ok, base);
+}
+
+int64_t String::toInt64Strict(bool* ok, int base) const
+{
+    if (!m_impl) {
+        if (ok)
+            *ok = false;
+        return 0;
+    }
+    return m_impl->toInt64Strict(ok, base);
+}
+
+uint64_t String::toUInt64Strict(bool* ok, int base) const
+{
+    if (!m_impl) {
+        if (ok)
+            *ok = false;
+        return 0;
+    }
+    return m_impl->toUInt64Strict(ok, base);
+}
+
 int String::toInt(bool* ok) const
 {
     if (!m_impl) {
@@ -410,6 +457,16 @@ int String::toInt(bool* ok) const
     return m_impl->toInt(ok);
 }
 
+unsigned String::toUInt(bool* ok) const
+{
+    if (!m_impl) {
+        if (ok)
+            *ok = false;
+        return 0;
+    }
+    return m_impl->toUInt(ok);
+}
+
 int64_t String::toInt64(bool* ok) const
 {
     if (!m_impl) {
@@ -435,7 +492,7 @@ double String::toDouble(bool* ok) const
     if (!m_impl) {
         if (ok)
             *ok = false;
-        return 0;
+        return 0.0;
     }
     return m_impl->toDouble(ok);
 }
@@ -587,6 +644,177 @@ String::operator UString() const
     return UString(reinterpret_cast<const KJS::UChar*>(m_impl->characters()), m_impl->length());
 }
 
+// String Operations
+
+static bool isCharacterAllowedInBase(UChar c, int base)
+{
+    if (c > 0x7F)
+        return false;
+    if (isASCIIDigit(c))
+        return c - '0' < base;
+    if (isASCIIAlpha(c)) {
+        if (base > 36)
+            base = 36;
+        return (c >= 'a' && c < 'a' + base - 10)
+            || (c >= 'A' && c < 'A' + base - 10);
+    }
+    return false;
+}
+
+template <typename IntegralType>
+static inline IntegralType toIntegralType(const UChar* data, size_t length, bool* ok, int base)
+{
+    static const IntegralType integralMax = std::numeric_limits<IntegralType>::max();
+    static const bool isSigned = std::numeric_limits<IntegralType>::is_signed;
+    const IntegralType maxMultiplier = integralMax / base;
+
+    IntegralType value = 0;
+    bool isOk = false;
+    bool isNegative = false;
+
+    if (!data)
+        goto bye;
+
+    // skip leading whitespace
+    while (length && isSpaceOrNewline(*data)) {
+        length--;
+        data++;
+    }
+
+    if (isSigned && length && *data == '-') {
+        length--;
+        data++;
+        isNegative = true;
+    } else if (length && *data == '+') {
+        length--;
+        data++;
+    }
+
+    if (!length || !isCharacterAllowedInBase(*data, base))
+        goto bye;
+
+    while (length && isCharacterAllowedInBase(*data, base)) {
+        length--;
+        IntegralType digitValue;
+        UChar c = *data;
+        if (isASCIIDigit(c))
+            digitValue = c - '0';
+        else if (c >= 'a')
+            digitValue = c - 'a' + 10;
+        else
+            digitValue = c - 'A' + 10;
+
+        if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative))
+            goto bye;
+
+        value = base * value + digitValue;
+        data++;
+    }
+
+    if (isNegative)
+        value = -value;
+
+    // skip trailing space
+    while (length && isSpaceOrNewline(*data)) {
+        length--;
+        data++;
+    }
+
+    if (!length)
+        isOk = true;
+bye:
+    if (ok)
+        *ok = isOk;
+    return isOk ? value : 0;
+}
+
+static unsigned lengthOfCharactersAsInteger(const UChar* data, size_t length)
+{
+    size_t i = 0;
+
+    // Allow leading spaces.
+    for (; i != length; ++i) {
+        if (!isSpaceOrNewline(data[i]))
+            break;
+    }
+    
+    // Allow sign.
+    if (i != length && (data[i] == '+' || data[i] == '-'))
+        ++i;
+    
+    // Allow digits.
+    for (; i != length; ++i) {
+        if (!Unicode::isDigit(data[i]))
+            break;
+    }
+
+    return i;
+}
+
+int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base)
+{
+    return toIntegralType<int>(data, length, ok, base);
+}
+
+unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base)
+{
+    return toIntegralType<unsigned>(data, length, ok, base);
+}
+
+int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base)
+{
+    return toIntegralType<int64_t>(data, length, ok, base);
+}
+
+uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base)
+{
+    return toIntegralType<uint64_t>(data, length, ok, base);
+}
+
+int charactersToInt(const UChar* data, size_t length, bool* ok)
+{
+    return toIntegralType<int>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
+}
+
+unsigned charactersToUInt(const UChar* data, size_t length, bool* ok)
+{
+    return toIntegralType<unsigned>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
+}
+
+int64_t charactersToInt64(const UChar* data, size_t length, bool* ok)
+{
+    return toIntegralType<int64_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
+}
+
+uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok)
+{
+    return toIntegralType<uint64_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
+}
+
+double charactersToDouble(const UChar* data, size_t length, bool* ok)
+{
+    if (!length) {
+        if (ok)
+            *ok = false;
+        return 0.0;
+    }
+
+    // FIXME: This should be made more efficient by using a fixed-sized stack buffer
+    // to avoid the allocation. 
+    char* end;
+    CString latin1String = Latin1Encoding().encode(data, length);
+    double val = kjs_strtod(latin1String.data(), &end);
+    if (ok)
+        *ok = (end == 0 || *end == '\0');
+    return val;
+}
+
+float charactersToFloat(const UChar* data, size_t length, bool* ok)
+{
+    // FIXME: This will return ok even when the string fits into a double but not a float.
+    return narrowPrecisionToFloat(charactersToDouble(data, length, ok));
+}
+
 } // namespace WebCore
 
 #ifndef NDEBUG
index 0643de6..9c4895e 100644 (file)
@@ -225,7 +225,7 @@ static Length parseLength(const UChar* data, unsigned length)
         ++i;
 
     bool ok;
-    int r = DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(data), i).string().toInt(&ok);
+    int r = charactersToIntStrict(data, i, &ok);
 
     /* Skip over any remaining digits, we are not that accurate (5.5% => 5%) */
     while (i < length && (Unicode::isDigit(data[i]) || data[i] == '.'))
@@ -513,84 +513,54 @@ PassRefPtr<StringImpl> StringImpl::capitalize(UChar previous)
     return adopt(data);
 }
 
-int StringImpl::toInt(bool* ok)
+int StringImpl::toIntStrict(bool* ok, int base)
 {
-    unsigned i = 0;
+    return charactersToIntStrict(m_data, m_length, ok, base);
+}
 
-    // Allow leading spaces.
-    for (; i != m_length; ++i)
-        if (!isSpaceOrNewline(m_data[i]))
-            break;
-    
-    // Allow sign.
-    if (i != m_length && (m_data[i] == '+' || m_data[i] == '-'))
-        ++i;
-    
-    // Allow digits.
-    for (; i != m_length; ++i)
-        if (!Unicode::isDigit(m_data[i]))
-            break;
-    
-    return DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toInt(ok);
+unsigned StringImpl::toUIntStrict(bool* ok, int base)
+{
+    return charactersToUIntStrict(m_data, m_length, ok, base);
 }
 
-int64_t StringImpl::toInt64(bool* ok)
+int64_t StringImpl::toInt64Strict(bool* ok, int base)
 {
-    unsigned i = 0;
+    return charactersToInt64Strict(m_data, m_length, ok, base);
+}
 
-    // Allow leading spaces.
-    for (; i != m_length; ++i)
-        if (!isSpaceOrNewline(m_data[i]))
-            break;
-    
-    // Allow sign.
-    if (i != m_length && (m_data[i] == '+' || m_data[i] == '-'))
-        ++i;
-    
-    // Allow digits.
-    for (; i != m_length; ++i)
-        if (!Unicode::isDigit(m_data[i]))
-            break;
-    
-    return DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toInt64(ok);
+uint64_t StringImpl::toUInt64Strict(bool* ok, int base)
+{
+    return charactersToUInt64Strict(m_data, m_length, ok, base);
 }
 
-uint64_t StringImpl::toUInt64(bool* ok)
+int StringImpl::toInt(bool* ok)
 {
-    unsigned i = 0;
+    return charactersToInt(m_data, m_length, ok);
+}
 
-    // Allow leading spaces.
-    for (; i != m_length; ++i)
-        if (!isSpaceOrNewline(m_data[i]))
-            break;
+unsigned StringImpl::toUInt(bool* ok)
+{
+    return charactersToUInt(m_data, m_length, ok);
+}
 
-    // Allow digits.
-    for (; i != m_length; ++i)
-        if (!Unicode::isDigit(m_data[i]))
-            break;
-    
-    return DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toUInt64(ok);
+int64_t StringImpl::toInt64(bool* ok)
+{
+    return charactersToInt64(m_data, m_length, ok);
+}
+
+uint64_t StringImpl::toUInt64(bool* ok)
+{
+    return charactersToUInt64(m_data, m_length, ok);
 }
 
 double StringImpl::toDouble(bool* ok)
 {
-    if (!m_length) {
-        if (ok)
-            *ok = false;
-        return 0;
-    }
-    char *end;
-    CString latin1String = Latin1Encoding().encode(characters(), length());
-    double val = kjs_strtod(latin1String.data(), &end);
-    if (ok)
-        *ok = end == 0 || *end == '\0';
-    return val;
+    return charactersToDouble(m_data, m_length, ok);
 }
 
 float StringImpl::toFloat(bool* ok)
 {
-    // FIXME: This will return ok even when the string fits into a double but not a float.
-    return narrowPrecisionToFloat(toDouble(ok));
+    return charactersToFloat(m_data, m_length, ok);
 }
 
 static bool equal(const UChar* a, const char* b, int length)
index dd50b2e..1fb1e95 100644 (file)
@@ -49,6 +49,9 @@ struct StringHash;
 struct UCharBufferTranslator;
 
 class StringImpl : public RefCounted<StringImpl> {
+    friend class AtomicString;
+    friend struct UCharBufferTranslator;
+    friend struct CStringTranslator;
 private:
     StringImpl();
     StringImpl(const UChar*, unsigned length);
@@ -99,9 +102,16 @@ public:
 
     bool containsOnlyWhitespace();
 
-    int toInt(bool* ok = 0); // ignores trailing garbage, unlike DeprecatedString
-    int64_t toInt64(bool* ok = 0); // ignores trailing garbage, unlike DeprecatedString
-    uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage, unlike DeprecatedString
+    int toIntStrict(bool* ok = 0, int base = 10);
+    unsigned toUIntStrict(bool* ok = 0, int base = 10);
+    int64_t toInt64Strict(bool* ok = 0, int base = 10);
+    uint64_t toUInt64Strict(bool* ok = 0, int base = 10);
+
+    int toInt(bool* ok = 0); // ignores trailing garbage
+    unsigned toUInt(bool* ok = 0); // ignores trailing garbage
+    int64_t toInt64(bool* ok = 0); // ignores trailing garbage
+    uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage
+
     double toDouble(bool* ok = 0);
     float toFloat(bool* ok = 0);
 
@@ -146,10 +156,6 @@ public:
 #endif
 
 private:
-    friend class AtomicString;
-    friend struct UCharBufferTranslator;
-    friend struct CStringTranslator;
-
     unsigned m_length;
     const UChar* m_data;
     mutable unsigned m_hash;
index 5ccc17f..35c3218 100644 (file)
@@ -313,9 +313,9 @@ void SVGAnimationElement::parseMappedAttribute(MappedAttribute* attr)
 
 double SVGAnimationElement::parseClockValue(const String& data)
 {
-    DeprecatedString parse = data.deprecatedString().stripWhiteSpace();
-    
-    if (parse == "indefinite") // Saves some time...
+    String parse = data.stripWhiteSpace();
+
+    if (parse == "indefinite")
         return DBL_MAX;
 
     double result;
@@ -324,28 +324,28 @@ double SVGAnimationElement::parseClockValue(const String& data)
     int doublePointTwo = parse.find(':', doublePointOne + 1);
 
     if (doublePointOne != -1 && doublePointTwo != -1) { // Spec: "Full clock values"
-        unsigned int hours = parse.mid(0, 2).toUInt();
-        unsigned int minutes = parse.mid(3, 2).toUInt();
-        unsigned int seconds = parse.mid(6, 2).toUInt();
-        unsigned int milliseconds = 0;
+        unsigned hours = parse.substring(0, 2).toUIntStrict();
+        unsigned minutes = parse.substring(3, 2).toUIntStrict();
+        unsigned seconds = parse.substring(6, 2).toUIntStrict();
+        unsigned milliseconds = 0;
 
         result = (3600 * hours) + (60 * minutes) + seconds;
 
         if (parse.find('.') != -1) {
-            DeprecatedString temp = parse.mid(9, 2);
-            milliseconds = temp.toUInt();
+            String temp = parse.substring(9, 2);
+            milliseconds = temp.toUIntStrict();
             result += (milliseconds * (1 / pow(10.0, int(temp.length()))));
         }
     } else if (doublePointOne != -1 && doublePointTwo == -1) { // Spec: "Partial clock values"
-        unsigned int minutes = parse.mid(0, 2).toUInt();
-        unsigned int seconds = parse.mid(3, 2).toUInt();
-        unsigned int milliseconds = 0;
+        unsigned minutes = parse.substring(0, 2).toUIntStrict();
+        unsigned seconds = parse.substring(3, 2).toUIntStrict();
+        unsigned milliseconds = 0;
 
         result = (60 * minutes) + seconds;
 
         if (parse.find('.') != -1) {
-            DeprecatedString temp = parse.mid(6, 2);
-            milliseconds = temp.toUInt();
+            String temp = parse.substring(6, 2);
+            milliseconds = temp.toUIntStrict();
             result += (milliseconds * (1 / pow(10.0, int(temp.length()))));
         }
     } else { // Spec: "Timecount values"
@@ -353,35 +353,35 @@ double SVGAnimationElement::parseClockValue(const String& data)
 
         if (parse.endsWith("h")) {
             if (dotPosition == -1)
-                result = parse.mid(0, parse.length() - 1).toUInt() * 3600;
+                result = parse.substring(0, parse.length() - 1).toUIntStrict() * 3600;
             else {
-                result = parse.mid(0, dotPosition).toUInt() * 3600;
-                DeprecatedString temp = parse.mid(dotPosition + 1, parse.length() - dotPosition - 2);
-                result += (3600.0 * temp.toUInt()) * (1 / pow(10.0, int(temp.length())));
+                result = parse.substring(0, dotPosition).toUIntStrict() * 3600;
+                String temp = parse.substring(dotPosition + 1, parse.length() - dotPosition - 2);
+                result += (3600.0 * temp.toUIntStrict()) * (1 / pow(10.0, int(temp.length())));
             }
         } else if (parse.endsWith("min")) {
             if (dotPosition == -1)
-                result = parse.mid(0, parse.length() - 3).toUInt() * 60;
+                result = parse.substring(0, parse.length() - 3).toUIntStrict() * 60;
             else {
-                result = parse.mid(0, dotPosition).toUInt() * 60;
-                DeprecatedString temp = parse.mid(dotPosition + 1, parse.length() - dotPosition - 4);
-                result += (60.0 * temp.toUInt()) * (1 / pow(10.0, int(temp.length())));
+                result = parse.substring(0, dotPosition).toUIntStrict() * 60;
+                String temp = parse.substring(dotPosition + 1, parse.length() - dotPosition - 4);
+                result += (60.0 * temp.toUIntStrict()) * (1 / pow(10.0, int(temp.length())));
             }
         } else if (parse.endsWith("ms")) {
             if (dotPosition == -1)
-                result = parse.mid(0, parse.length() - 2).toUInt() / 1000.0;
+                result = parse.substring(0, parse.length() - 2).toUIntStrict() / 1000.0;
             else {
-                result = parse.mid(0, dotPosition).toUInt() / 1000.0;
-                DeprecatedString temp = parse.mid(dotPosition + 1, parse.length() - dotPosition - 3);
-                result += (temp.toUInt() / 1000.0) * (1 / pow(10.0, int(temp.length())));
+                result = parse.substring(0, dotPosition).toUIntStrict() / 1000.0;
+                String temp = parse.substring(dotPosition + 1, parse.length() - dotPosition - 3);
+                result += (temp.toUIntStrict() / 1000.0) * (1 / pow(10.0, int(temp.length())));
             }
         } else if (parse.endsWith("s")) {
             if (dotPosition == -1)
-                result = parse.mid(0, parse.length() - 1).toUInt();
+                result = parse.substring(0, parse.length() - 1).toUIntStrict();
             else {
-                result = parse.mid(0, dotPosition).toUInt();
-                DeprecatedString temp = parse.mid(dotPosition + 1, parse.length() - dotPosition - 2);
-                result += temp.toUInt() * (1 / pow(10.0, int(temp.length())));
+                result = parse.substring(0, dotPosition).toUIntStrict();
+                String temp = parse.substring(dotPosition + 1, parse.length() - dotPosition - 2);
+                result += temp.toUIntStrict() * (1 / pow(10.0, int(temp.length())));
             }
         } else
             result = parse.toDouble();
index 0abc83c..e047e8a 100644 (file)
@@ -76,7 +76,7 @@ void SVGFETurbulenceElement::parseMappedAttribute(MappedAttribute* attr)
     } else if (attr->name() == SVGNames::seedAttr)
         setSeedBaseValue(value.toFloat());
     else if (attr->name() == SVGNames::numOctavesAttr)
-        setNumOctavesBaseValue(value.deprecatedString().toUInt());
+        setNumOctavesBaseValue(value.toUIntStrict());
     else
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }