JavaScriptCore-1218.34.tar.gz

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

diff --git a/runtime/ClassInfo.h b/runtime/ClassInfo.h
index 097fb09962bd84668ce749a822d0cb81612e0fd8..af1d71e13043971ec253b0aeaa80066790e13611 100644 (file)
--- a/runtime/ClassInfo.h
+++ b/runtime/ClassInfo.h
@@ -24,38 +24,171 @@
 #define ClassInfo_h
 
 #include "CallFrame.h"
+#include "ConstructData.h"
+#include "JSCell.h"
 
 namespace JSC {
 
-    struct HashEntry;
-    struct HashTable;
-
-    struct ClassInfo {
-        /**
-         * A string denoting the class name. Example: "Window".
-         */
-        const char* className;
-
-        /**
-         * Pointer to the class information of the base class.
-         * 0L if there is none.
-         */
-        const ClassInfo* parentClass;
-        /**
-         * Static hash-table of properties.
-         * For classes that can be used from multiple threads, it is accessed via a getter function that would typically return a pointer to thread-specific value.
-         */
-        const HashTable* propHashTable(ExecState* exec) const
-        {
-            if (classPropHashTableGetterFunction)
-                return classPropHashTableGetterFunction(exec);
-            return staticPropHashTable;
+class HashEntry;
+struct HashTable;
+
+struct MethodTable {
+    typedef void (*DestroyFunctionPtr)(JSCell*);
+    DestroyFunctionPtr destroy;
+
+    typedef void (*VisitChildrenFunctionPtr)(JSCell*, SlotVisitor&);
+    VisitChildrenFunctionPtr visitChildren;
+
+    typedef void (*CopyBackingStoreFunctionPtr)(JSCell*, CopyVisitor&);
+    CopyBackingStoreFunctionPtr copyBackingStore;
+
+    typedef CallType (*GetCallDataFunctionPtr)(JSCell*, CallData&);
+    GetCallDataFunctionPtr getCallData;
+
+    typedef ConstructType (*GetConstructDataFunctionPtr)(JSCell*, ConstructData&);
+    GetConstructDataFunctionPtr getConstructData;
+
+    typedef void (*PutFunctionPtr)(JSCell*, ExecState*, PropertyName propertyName, JSValue, PutPropertySlot&);
+    PutFunctionPtr put;
+
+    typedef void (*PutByIndexFunctionPtr)(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
+    PutByIndexFunctionPtr putByIndex;
+
+    typedef bool (*DeletePropertyFunctionPtr)(JSCell*, ExecState*, PropertyName);
+    DeletePropertyFunctionPtr deleteProperty;
+
+    typedef bool (*DeletePropertyByIndexFunctionPtr)(JSCell*, ExecState*, unsigned);
+    DeletePropertyByIndexFunctionPtr deletePropertyByIndex;
+
+    typedef bool (*GetOwnPropertySlotFunctionPtr)(JSCell*, ExecState*, PropertyName, PropertySlot&);
+    GetOwnPropertySlotFunctionPtr getOwnPropertySlot;
+
+    typedef bool (*GetOwnPropertySlotByIndexFunctionPtr)(JSCell*, ExecState*, unsigned, PropertySlot&);
+    GetOwnPropertySlotByIndexFunctionPtr getOwnPropertySlotByIndex;
+
+    typedef JSObject* (*ToThisObjectFunctionPtr)(JSCell*, ExecState*);
+    ToThisObjectFunctionPtr toThisObject;
+
+    typedef JSValue (*DefaultValueFunctionPtr)(const JSObject*, ExecState*, PreferredPrimitiveType);
+    DefaultValueFunctionPtr defaultValue;
+
+    typedef void (*GetOwnPropertyNamesFunctionPtr)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+    GetOwnPropertyNamesFunctionPtr getOwnPropertyNames;
+
+    typedef void (*GetOwnNonIndexPropertyNamesFunctionPtr)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+    GetOwnNonIndexPropertyNamesFunctionPtr getOwnNonIndexPropertyNames;
+
+    typedef void (*GetPropertyNamesFunctionPtr)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+    GetPropertyNamesFunctionPtr getPropertyNames;
+
+    typedef String (*ClassNameFunctionPtr)(const JSObject*);
+    ClassNameFunctionPtr className;
+
+    typedef bool (*CustomHasInstanceFunctionPtr)(JSObject*, ExecState*, JSValue);
+    CustomHasInstanceFunctionPtr customHasInstance;
+
+    typedef void (*PutWithAttributesFunctionPtr)(JSObject*, ExecState*, PropertyName propertyName, JSValue, unsigned attributes);
+    PutWithAttributesFunctionPtr putDirectVirtual;
+
+    typedef bool (*DefineOwnPropertyFunctionPtr)(JSObject*, ExecState*, PropertyName, PropertyDescriptor&, bool);
+    DefineOwnPropertyFunctionPtr defineOwnProperty;
+
+    typedef bool (*GetOwnPropertyDescriptorFunctionPtr)(JSObject*, ExecState*, PropertyName, PropertyDescriptor&);
+    GetOwnPropertyDescriptorFunctionPtr getOwnPropertyDescriptor;
+};
+
+#define CREATE_MEMBER_CHECKER(member) \
+    template <typename T> \
+    struct MemberCheck##member { \
+        struct Fallback { \
+            void member(...); \
+        }; \
+        struct Derived : T, Fallback { }; \
+        template <typename U, U> struct Check; \
+        typedef char Yes[2]; \
+        typedef char No[1]; \
+        template <typename U> \
+        static No &func(Check<void (Fallback::*)(...), &U::member>*); \
+        template <typename U> \
+        static Yes &func(...); \
+        enum { has = sizeof(func<Derived>(0)) == sizeof(Yes) }; \
+    }
+
+#define HAS_MEMBER_NAMED(klass, name) (MemberCheck##name<klass>::has)
+
+#define CREATE_METHOD_TABLE(ClassName) { \
+        &ClassName::destroy, \
+        &ClassName::visitChildren, \
+        &ClassName::copyBackingStore, \
+        &ClassName::getCallData, \
+        &ClassName::getConstructData, \
+        &ClassName::put, \
+        &ClassName::putByIndex, \
+        &ClassName::deleteProperty, \
+        &ClassName::deletePropertyByIndex, \
+        &ClassName::getOwnPropertySlot, \
+        &ClassName::getOwnPropertySlotByIndex, \
+        &ClassName::toThisObject, \
+        &ClassName::defaultValue, \
+        &ClassName::getOwnPropertyNames, \
+        &ClassName::getOwnNonIndexPropertyNames, \
+        &ClassName::getPropertyNames, \
+        &ClassName::className, \
+        &ClassName::customHasInstance, \
+        &ClassName::putDirectVirtual, \
+        &ClassName::defineOwnProperty, \
+        &ClassName::getOwnPropertyDescriptor, \
+    }, \
+    ClassName::TypedArrayStorageType
+
+struct ClassInfo {
+    /**
+     * A string denoting the class name. Example: "Window".
+     */
+    const char* className;
+
+    /**
+     * Pointer to the class information of the base class.
+     * 0L if there is none.
+     */
+    const ClassInfo* parentClass;
+    /**
+     * Static hash-table of properties.
+     * For classes that can be used from multiple threads, it is accessed via a getter function that would typically return a pointer to thread-specific value.
+     */
+    const HashTable* propHashTable(ExecState* exec) const
+    {
+        if (classPropHashTableGetterFunction)
+            return classPropHashTableGetterFunction(exec);
+        return staticPropHashTable;
+    }
+        
+    bool isSubClassOf(const ClassInfo* other) const
+    {
+        for (const ClassInfo* ci = this; ci; ci = ci->parentClass) {
+            if (ci == other)
+                return true;
         }
+        return false;
+    }
+
+    bool hasStaticProperties() const
+    {
+        for (const ClassInfo* ci = this; ci; ci = ci->parentClass) {
+            if (ci->staticPropHashTable || ci->classPropHashTableGetterFunction)
+                return true;
+        }
+        return false;
+    }
+
+    const HashTable* staticPropHashTable;
+    typedef const HashTable* (*ClassPropHashTableGetterFunction)(ExecState*);
+    const ClassPropHashTableGetterFunction classPropHashTableGetterFunction;
+
+    MethodTable methodTable;
 
-        const HashTable* staticPropHashTable;
-        typedef const HashTable* (*ClassPropHashTableGetterFunction)(ExecState*);
-        const ClassPropHashTableGetterFunction classPropHashTableGetterFunction;
-    };
+    TypedArrayType typedArrayStorageType;
+};
 
 } // namespace JSC