X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/b80e619319b1def83d1e8b4f84042b661be1be7f..14957cd040308e3eeec43d26bae5d76da13fcd85:/runtime/Identifier.h

diff --git a/runtime/Identifier.h b/runtime/Identifier.h
index 2f16bbf..36b336e 100644
--- a/runtime/Identifier.h
+++ b/runtime/Identifier.h
@@ -24,6 +24,7 @@
 #include "JSGlobalData.h"
 #include "ThreadSpecific.h"
 #include "UString.h"
+#include <wtf/text/CString.h>
 
 namespace JSC {
 
@@ -34,38 +35,37 @@ namespace JSC {
     public:
         Identifier() { }
 
-        Identifier(ExecState* exec, const char* s) : _ustring(add(exec, s)) { } // Only to be used with string literals.
-        Identifier(ExecState* exec, const UChar* s, int length) : _ustring(add(exec, s, length)) { }
-        Identifier(ExecState* exec, UString::Rep* rep) : _ustring(add(exec, rep)) { } 
-        Identifier(ExecState* exec, const UString& s) : _ustring(add(exec, s.rep())) { }
+        Identifier(ExecState* exec, const char* s) : m_string(add(exec, s)) { } // Only to be used with string literals.
+        Identifier(ExecState* exec, const UChar* s, int length) : m_string(add(exec, s, length)) { }
+        Identifier(ExecState* exec, StringImpl* rep) : m_string(add(exec, rep)) { } 
+        Identifier(ExecState* exec, const UString& s) : m_string(add(exec, s.impl())) { }
 
-        Identifier(JSGlobalData* globalData, const char* s) : _ustring(add(globalData, s)) { } // Only to be used with string literals.
-        Identifier(JSGlobalData* globalData, const UChar* s, int length) : _ustring(add(globalData, s, length)) { }
-        Identifier(JSGlobalData* globalData, UString::Rep* rep) : _ustring(add(globalData, rep)) { } 
-        Identifier(JSGlobalData* globalData, const UString& s) : _ustring(add(globalData, s.rep())) { }
+        Identifier(JSGlobalData* globalData, const char* s) : m_string(add(globalData, s)) { } // Only to be used with string literals.
+        Identifier(JSGlobalData* globalData, const UChar* s, int length) : m_string(add(globalData, s, length)) { }
+        Identifier(JSGlobalData* globalData, StringImpl* rep) : m_string(add(globalData, rep)) { } 
+        Identifier(JSGlobalData* globalData, const UString& s) : m_string(add(globalData, s.impl())) { }
 
-        // Special constructor for cases where we overwrite an object in place.
-        Identifier(PlacementNewAdoptType) : _ustring(PlacementNewAdopt) { }
+        const UString& ustring() const { return m_string; }
+        StringImpl* impl() const { return m_string.impl(); }
         
-        const UString& ustring() const { return _ustring; }
+        const UChar* characters() const { return m_string.characters(); }
+        int length() const { return m_string.length(); }
         
-        const UChar* data() const { return _ustring.data(); }
-        int size() const { return _ustring.size(); }
-        
-        const char* ascii() const { return _ustring.ascii(); }
+        CString ascii() const { return m_string.ascii(); }
         
         static Identifier from(ExecState* exec, unsigned y);
         static Identifier from(ExecState* exec, int y);
         static Identifier from(ExecState* exec, double y);
-        
-        bool isNull() const { return _ustring.isNull(); }
-        bool isEmpty() const { return _ustring.isEmpty(); }
-        
-        uint32_t toUInt32(bool* ok) const { return _ustring.toUInt32(ok); }
-        uint32_t toUInt32(bool* ok, bool tolerateEmptyString) const { return _ustring.toUInt32(ok, tolerateEmptyString); };
-        uint32_t toStrictUInt32(bool* ok) const { return _ustring.toStrictUInt32(ok); }
-        unsigned toArrayIndex(bool* ok) const { return _ustring.toArrayIndex(ok); }
-        double toDouble() const { return _ustring.toDouble(); }
+        static Identifier from(JSGlobalData*, unsigned y);
+        static Identifier from(JSGlobalData*, int y);
+        static Identifier from(JSGlobalData*, double y);
+
+        static uint32_t toUInt32(const UString&, bool& ok);
+        uint32_t toUInt32(bool& ok) const { return toUInt32(m_string, ok); }
+        unsigned toArrayIndex(bool& ok) const;
+
+        bool isNull() const { return m_string.isNull(); }
+        bool isEmpty() const { return m_string.isEmpty(); }
         
         friend bool operator==(const Identifier&, const Identifier&);
         friend bool operator!=(const Identifier&, const Identifier&);
@@ -73,23 +73,23 @@ namespace JSC {
         friend bool operator==(const Identifier&, const char*);
         friend bool operator!=(const Identifier&, const char*);
     
-        static bool equal(const UString::Rep*, const char*);
-        static bool equal(const UString::Rep*, const UChar*, unsigned length);
-        static bool equal(const UString::Rep* a, const UString::Rep* b) { return ::equal(a, b); }
+        static bool equal(const StringImpl*, const char*);
+        static bool equal(const StringImpl*, const UChar*, unsigned length);
+        static bool equal(const StringImpl* a, const StringImpl* b) { return ::equal(a, b); }
 
-        static PassRefPtr<UString::Rep> add(ExecState*, const char*); // Only to be used with string literals.
-        static PassRefPtr<UString::Rep> add(JSGlobalData*, const char*); // Only to be used with string literals.
+        static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
+        static PassRefPtr<StringImpl> add(JSGlobalData*, const char*); // Only to be used with string literals.
 
     private:
-        UString _ustring;
+        UString m_string;
         
-        static bool equal(const Identifier& a, const Identifier& b) { return a._ustring.rep() == b._ustring.rep(); }
-        static bool equal(const Identifier& a, const char* b) { return equal(a._ustring.rep(), b); }
+        static bool equal(const Identifier& a, const Identifier& b) { return a.m_string.impl() == b.m_string.impl(); }
+        static bool equal(const Identifier& a, const char* b) { return equal(a.m_string.impl(), b); }
 
-        static PassRefPtr<UString::Rep> add(ExecState*, const UChar*, int length);
-        static PassRefPtr<UString::Rep> add(JSGlobalData*, const UChar*, int length);
+        static PassRefPtr<StringImpl> add(ExecState*, const UChar*, int length);
+        static PassRefPtr<StringImpl> add(JSGlobalData*, const UChar*, int length);
 
-        static PassRefPtr<UString::Rep> add(ExecState* exec, UString::Rep* r)
+        static PassRefPtr<StringImpl> add(ExecState* exec, StringImpl* r)
         {
 #ifndef NDEBUG
             checkCurrentIdentifierTable(exec);
@@ -98,7 +98,7 @@ namespace JSC {
                 return r;
             return addSlowCase(exec, r);
         }
-        static PassRefPtr<UString::Rep> add(JSGlobalData* globalData, UString::Rep* r)
+        static PassRefPtr<StringImpl> add(JSGlobalData* globalData, StringImpl* r)
         {
 #ifndef NDEBUG
             checkCurrentIdentifierTable(globalData);
@@ -108,8 +108,8 @@ namespace JSC {
             return addSlowCase(globalData, r);
         }
 
-        static PassRefPtr<UString::Rep> addSlowCase(ExecState*, UString::Rep* r);
-        static PassRefPtr<UString::Rep> addSlowCase(JSGlobalData*, UString::Rep* r);
+        static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl* r);
+        static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl* r);
 
         static void checkCurrentIdentifierTable(ExecState*);
         static void checkCurrentIdentifierTable(JSGlobalData*);
@@ -135,9 +135,25 @@ namespace JSC {
         return !Identifier::equal(a, b);
     }
 
+    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;
+    }
+    
     IdentifierTable* createIdentifierTable();
     void deleteIdentifierTable(IdentifierTable*);
 
+    struct IdentifierRepHash : PtrHash<RefPtr<StringImpl> > {
+        static unsigned hash(const RefPtr<StringImpl>& key) { return key->existingHash(); }
+        static unsigned hash(StringImpl* key) { return key->existingHash(); }
+    };
+
 } // namespace JSC
 
 #endif // Identifier_h