Changeset 94475 in webkit for trunk/Source/JavaScriptCore

Timestamp:

Sep 2, 2011, 6:08:10 PM (14 years ago)

Author:

[email protected]

Message:

Replace local implementation of string equals() methods with UString versions
​https://bugs.webkit.org/show_bug.cgi?id=67342

In preparation to allowing StringImpl to be backed by 8 bit
characters when appropriate, we need to eliminate or change the
usage of StringImpl::characters(). Change the uses of characters()
that are used to implement redundant equals() methods.

Reviewed by Gavin Barraclough.

• runtime/Identifier.cpp:

(JSC::Identifier::equal):

• runtime/Identifier.h:

(JSC::Identifier::equal):

• wtf/text/AtomicString.cpp:

(WTF::CStringTranslator::equal): Moved an optimized method to here.
(WTF::operator==):

• wtf/text/StringImpl.cpp:

(WTF::equal):

• wtf/text/StringImpl.h:

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• JavaScriptCore.exp (modified) (3 diffs)
• runtime/Identifier.cpp (modified) (1 diff)
• runtime/Identifier.h (modified) (1 diff)
• wtf/text/AtomicString.cpp (modified) (3 diffs)
• wtf/text/AtomicString.h (modified) (1 diff)
• wtf/text/StringImpl.cpp (modified) (1 diff)
• wtf/text/StringImpl.h (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2011-09-02  Michael Saboff  <[email protected]>
+
+        Replace local implementation of string equals() methods with UString versions
+        https://bugs.webkit.org/show_bug.cgi?id=67342
+
+        In preparation to allowing StringImpl to be backed by 8 bit 
+        characters when appropriate, we need to eliminate or change the
+        usage of StringImpl::characters(). Change the uses of characters()
+        that are used to implement redundant equals() methods.
+
+        Reviewed by Gavin Barraclough.
+
+        * runtime/Identifier.cpp:
+        (JSC::Identifier::equal):
+        * runtime/Identifier.h:
+        (JSC::Identifier::equal):
+        * wtf/text/AtomicString.cpp:
+        (WTF::CStringTranslator::equal): Moved an optimized method to here.
+        (WTF::operator==):
+        * wtf/text/StringImpl.cpp:
+        (WTF::equal):
+        * wtf/text/StringImpl.h:
+
 2011-09-02  Michael Saboff  <[email protected]>
 

trunk/Source/JavaScriptCore/JavaScriptCore.exp

@@ -109 +109 @@
 __ZN3JSC10Identifier4fromEPNS_9ExecStateEi
 __ZN3JSC10Identifier4fromEPNS_9ExecStateEj
-__ZN3JSC10Identifier5equalEPKN3WTF10StringImplEPKc
 __ZN3JSC10Identifier8toUInt32ERKNS_7UStringERb
 __ZN3JSC10JSFunction14finishCreationEPNS_9ExecStateEPNS_14JSGlobalObjectEPNS_18FunctionExecutableEPNS_14ScopeChainNodeE
@@ -478 +477 @@
 __ZN3WTF5MutexD1Ev
 __ZN3WTF5equalEPKNS_10StringImplEPKc
+__ZN3WTF5equalEPKNS_10StringImplEPKtj
 __ZN3WTF5equalEPKNS_10StringImplES2_
 __ZN3WTF5yieldEv
@@ -525 +525 @@
 __ZN3WTF9emptyAtomE
 __ZN3WTF9xmlnsAtomE
-__ZN3WTFeqERKNS_12AtomicStringEPKc
-__ZN3WTFeqERKNS_12AtomicStringERKNS_6VectorItLm0EEE
 __ZN3WTFeqERKNS_7CStringES2_
 __ZNK3JSC10JSFunction23isHostFunctionNonInlineEv

trunk/Source/JavaScriptCore/runtime/Identifier.cpp

@@ -68 +68 @@
 }
 
-bool Identifier::equal(const StringImpl* r, const char* s)
-{
-    int length = r->length();
-    const UChar* d = r->characters();
-    for (int i = 0; i != length; ++i)
-        if (d[i] != (unsigned char)s[i])
-            return false;
-    return s[length] == 0;
-}
-
 struct IdentifierCStringTranslator {
     static unsigned hash(const char* c)

trunk/Source/JavaScriptCore/runtime/Identifier.h

@@ -136 +136 @@
     }
 
+    inline bool Identifier::equal(const StringImpl* r, const char* s)
+    {
+        return WTF::equal(r, s);
+    }
+    
     inline bool Identifier::equal(const StringImpl* r, const UChar* s, unsigned length)
     {
-        if (r->length() != length)
-            return false;
-        const UChar* d = r->characters();
-        for (unsigned i = 0; i != length; ++i)
-            if (d[i] != s[i])
-                return false;
-        return true;
+        return WTF::equal(r, s, length);
     }
     

trunk/Source/JavaScriptCore/wtf/text/AtomicString.cpp

@@ -91 +91 @@
     }
 
-    static bool equal(StringImpl* r, const char* s)
-    {
-        int length = r->length();
-        const UChar* d = r->characters();
-        for (int i = 0; i != length; ++i) {
-            unsigned char c = s[i];
-            if (d[i] != c)
-                return false;
-        }
-        return !s[length];
+    static inline bool equal(StringImpl* r, const char* s)
+    {
+        return WTF::equal(r, s);
     }
 
@@ -111 +104 @@
 };
 
-bool operator==(const AtomicString& a, const char* b)
-{ 
-    StringImpl* impl = a.impl();
-    if ((!impl || !impl->characters()) && !b)
-        return true;
-    if ((!impl || !impl->characters()) || !b)
-        return false;
-    return CStringTranslator::equal(impl, b); 
-}
-
 PassRefPtr<StringImpl> AtomicString::add(const char* c)
 {
@@ -135 +118 @@
     unsigned length;
 };
-
-static inline bool equal(StringImpl* string, const UChar* characters, unsigned length)
-{
-    if (string->length() != length)
-        return false;
-
-    // FIXME: perhaps we should have a more abstract macro that indicates when
-    // going 4 bytes at a time is unsafe
-#if CPU(ARM) || CPU(SH4) || CPU(MIPS) || CPU(SPARC)
-    const UChar* stringCharacters = string->characters();
-    for (unsigned i = 0; i != length; ++i) {
-        if (*stringCharacters++ != *characters++)
-            return false;
-    }
-    return true;
-#else
-    /* Do it 4-bytes-at-a-time on architectures where it's safe */
-
-    const uint32_t* stringCharacters = reinterpret_cast<const uint32_t*>(string->characters());
-    const uint32_t* bufferCharacters = reinterpret_cast<const uint32_t*>(characters);
-
-    unsigned halfLength = length >> 1;
-    for (unsigned i = 0; i != halfLength; ++i) {
-        if (*stringCharacters++ != *bufferCharacters++)
-            return false;
-    }
-
-    if (length & 1 &&  *reinterpret_cast<const uint16_t*>(stringCharacters) != *reinterpret_cast<const uint16_t*>(bufferCharacters))
-        return false;
-
-    return true;
-#endif
-}
-
-bool operator==(const AtomicString& string, const Vector<UChar>& vector)
-{
-    return string.impl() && equal(string.impl(), vector.data(), vector.size());
-}
 
 struct UCharBufferTranslator {

trunk/Source/JavaScriptCore/wtf/text/AtomicString.h

@@ -136 +136 @@
 inline bool operator==(const AtomicString& a, const AtomicString& b) { return a.impl() == b.impl(); }
 bool operator==(const AtomicString& a, const char* b);
-bool operator==(const AtomicString& a, const Vector<UChar>& b);
+inline bool operator==(const AtomicString& a, const char* b) { return WTF::equal(a.impl(), b); }
+inline bool operator==(const AtomicString& a, const Vector<UChar>& b) { return a.impl() && equal(a.impl(), b.data(), b.size()); }    
 inline bool operator==(const AtomicString& a, const String& b) { return equal(a.impl(), b.impl()); }
 inline bool operator==(const char* a, const AtomicString& b) { return b == a; }

trunk/Source/JavaScriptCore/wtf/text/StringImpl.cpp

@@ -996 +996 @@
 }
 
+bool equal(const StringImpl* a, const UChar* b, unsigned length)
+{
+    if (!a)
+        return !b;
+    if (!b)
+        return false;
+
+    if (a->length() != length)
+        return false;
+    // FIXME: perhaps we should have a more abstract macro that indicates when
+    // going 4 bytes at a time is unsafe
+#if CPU(ARM) || CPU(SH4) || CPU(MIPS) || CPU(SPARC)
+    const UChar* as = a->characters();
+    for (unsigned i = 0; i != length; ++i)
+        if (as[i] != b[i])
+            return false;
+    return true;
+#else
+    /* Do it 4-bytes-at-a-time on architectures where it's safe */
+    
+    const uint32_t* aCharacters = reinterpret_cast<const uint32_t*>(a->characters());
+    const uint32_t* bCharacters = reinterpret_cast<const uint32_t*>(b);
+    
+    unsigned halfLength = length >> 1;
+    for (unsigned i = 0; i != halfLength; ++i) {
+        if (*aCharacters++ != *bCharacters++)
+            return false;
+    }
+    
+    if (length & 1 &&  *reinterpret_cast<const uint16_t*>(aCharacters) != *reinterpret_cast<const uint16_t*>(bCharacters))
+        return false;
+    
+    return true;
+#endif
+}
+
 bool equalIgnoringCase(StringImpl* a, StringImpl* b)
 {

trunk/Source/JavaScriptCore/wtf/text/StringImpl.h

@@ -348 +348 @@
 bool equal(const StringImpl*, const char*);
 inline bool equal(const char* a, StringImpl* b) { return equal(b, a); }
+bool equal(const StringImpl*, const UChar*, unsigned);
 
 bool equalIgnoringCase(StringImpl*, StringImpl*);