JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / runtime / RegExpKey.h

diff --git a/runtime/RegExpKey.h b/runtime/RegExpKey.h
index e5ab43892d9b41a6adced5fe9429c973192b8bf5..58fa38725a182124616146ba73e4198181b5a20f 100644 (file)
--- a/runtime/RegExpKey.h
+++ b/runtime/RegExpKey.h
@@ -25,64 +25,65 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "UString.h"
-
 #ifndef RegExpKey_h
 #define RegExpKey_h
 
+#include <wtf/text/StringHash.h>
+#include <wtf/text/WTFString.h>
+
 namespace JSC {
 
+enum RegExpFlags {
+    NoFlags = 0,
+    FlagGlobal = 1,
+    FlagIgnoreCase = 2,
+    FlagMultiline = 4,
+    InvalidFlags = 8,
+    DeletedValueFlags = -1
+};
+
 struct RegExpKey {
-    int flagsValue;
-    RefPtr<UString::Rep> pattern;
+    RegExpFlags flagsValue;
+    RefPtr<StringImpl> pattern;
 
     RegExpKey()
-        : flagsValue(0)
+        : flagsValue(NoFlags)
     {
     }
 
-    RegExpKey(int flags)
+    RegExpKey(RegExpFlags flags)
         : flagsValue(flags)
     {
     }
 
-    RegExpKey(int flags, const UString& pattern)
+    RegExpKey(RegExpFlags flags, const String& pattern)
         : flagsValue(flags)
-        , pattern(pattern.rep())
+        , pattern(pattern.impl())
     {
     }
 
-    RegExpKey(int flags, const PassRefPtr<UString::Rep> pattern)
+    RegExpKey(RegExpFlags flags, const PassRefPtr<StringImpl> pattern)
         : flagsValue(flags)
         , pattern(pattern)
     {
     }
 
-    RegExpKey(const UString& flags, const UString& pattern)
-        : pattern(pattern.rep())
+    RegExpKey(RegExpFlags flags, const RefPtr<StringImpl>& pattern)
+        : flagsValue(flags)
+        , pattern(pattern)
     {
-        flagsValue = getFlagsValue(flags);
     }
 
-    int getFlagsValue(const UString flags) 
-    {
-        flagsValue = 0;
-        if (flags.find('g') != UString::NotFound)
-            flagsValue += 4;
-        if (flags.find('i') != UString::NotFound)
-            flagsValue += 2;
-        if (flags.find('m') != UString::NotFound)
-            flagsValue += 1;
-        return flagsValue;
-    }
-};
-} // namespace JSC
+    friend inline bool operator==(const RegExpKey& a, const RegExpKey& b);
 
-namespace WTF {
-template<typename T> struct DefaultHash;
-template<typename T> struct RegExpHash;
+    struct Hash {
+        static unsigned hash(const RegExpKey& key) { return key.pattern->hash(); }
+        static bool equal(const RegExpKey& a, const RegExpKey& b) { return a == b; }
+        static const bool safeToCompareToEmptyOrDeleted = false;
+    };
+};
 
-inline bool operator==(const JSC::RegExpKey& a, const JSC::RegExpKey& b) 
+inline bool operator==(const RegExpKey& a, const RegExpKey& b)
 {
     if (a.flagsValue != b.flagsValue)
         return false;
@@ -93,19 +94,19 @@ inline bool operator==(const JSC::RegExpKey& a, const JSC::RegExpKey& b)
     return equal(a.pattern.get(), b.pattern.get());
 }
 
-template<> struct RegExpHash<JSC::RegExpKey> {
-    static unsigned hash(const JSC::RegExpKey& key) { return key.pattern->hash(); }
-    static bool equal(const JSC::RegExpKey& a, const JSC::RegExpKey& b) { return a == b; }
-    static const bool safeToCompareToEmptyOrDeleted = false;
-};
+} // namespace JSC
+
+namespace WTF {
+template<typename T> struct DefaultHash;
 
 template<> struct DefaultHash<JSC::RegExpKey> {
-    typedef RegExpHash<JSC::RegExpKey> Hash;
+    typedef JSC::RegExpKey::Hash Hash;
 };
 
 template<> struct HashTraits<JSC::RegExpKey> : GenericHashTraits<JSC::RegExpKey> {
-    static void constructDeletedValue(JSC::RegExpKey& slot) { slot.flagsValue = -1; }
-    static bool isDeletedValue(const JSC::RegExpKey& value) { return value.flagsValue == -1; }
+    static const bool emptyValueIsZero = true;
+    static void constructDeletedValue(JSC::RegExpKey& slot) { slot.flagsValue = JSC::DeletedValueFlags; }
+    static bool isDeletedValue(const JSC::RegExpKey& value) { return value.flagsValue == JSC::DeletedValueFlags; }
 };
 } // namespace WTF