runtime/ClassInfo.h

   1 /*
   2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
   4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Library General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Library General Public License
  17  *  along with this library; see the file COPYING.LIB.  If not, write to
  18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  *  Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #ifndef ClassInfo_h
  24 #define ClassInfo_h
  25
  26 #include "CallFrame.h"
  27 #include "ConstructData.h"
  28 #include "CopyToken.h"
  29 #include "JSCell.h"
  30
  31 namespace JSC {
  32
  33 class JSArrayBufferView;
  34 struct HashTable;
  35
  36 struct MethodTable {
  37     typedef void (*DestroyFunctionPtr)(JSCell*);
  38     DestroyFunctionPtr destroy;
  39
  40     typedef void (*VisitChildrenFunctionPtr)(JSCell*, SlotVisitor&);
  41     VisitChildrenFunctionPtr visitChildren;
  42
  43     typedef void (*CopyBackingStoreFunctionPtr)(JSCell*, CopyVisitor&, CopyToken);
  44     CopyBackingStoreFunctionPtr copyBackingStore;
  45
  46     typedef CallType (*GetCallDataFunctionPtr)(JSCell*, CallData&);
  47     GetCallDataFunctionPtr getCallData;
  48
  49     typedef ConstructType (*GetConstructDataFunctionPtr)(JSCell*, ConstructData&);
  50     GetConstructDataFunctionPtr getConstructData;
  51
  52     typedef void (*PutFunctionPtr)(JSCell*, ExecState*, PropertyName propertyName, JSValue, PutPropertySlot&);
  53     PutFunctionPtr put;
  54
  55     typedef void (*PutByIndexFunctionPtr)(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
  56     PutByIndexFunctionPtr putByIndex;
  57
  58     typedef bool (*DeletePropertyFunctionPtr)(JSCell*, ExecState*, PropertyName);
  59     DeletePropertyFunctionPtr deleteProperty;
  60
  61     typedef bool (*DeletePropertyByIndexFunctionPtr)(JSCell*, ExecState*, unsigned);
  62     DeletePropertyByIndexFunctionPtr deletePropertyByIndex;
  63
  64     typedef bool (*GetOwnPropertySlotFunctionPtr)(JSObject*, ExecState*, PropertyName, PropertySlot&);
  65     GetOwnPropertySlotFunctionPtr getOwnPropertySlot;
  66
  67     typedef bool (*GetOwnPropertySlotByIndexFunctionPtr)(JSObject*, ExecState*, unsigned, PropertySlot&);
  68     GetOwnPropertySlotByIndexFunctionPtr getOwnPropertySlotByIndex;
  69
  70     typedef JSValue (*ToThisFunctionPtr)(JSCell*, ExecState*, ECMAMode);
  71     ToThisFunctionPtr toThis;
  72
  73     typedef JSValue (*DefaultValueFunctionPtr)(const JSObject*, ExecState*, PreferredPrimitiveType);
  74     DefaultValueFunctionPtr defaultValue;
  75
  76     typedef void (*GetOwnPropertyNamesFunctionPtr)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
  77     GetOwnPropertyNamesFunctionPtr getOwnPropertyNames;
  78
  79     typedef void (*GetOwnNonIndexPropertyNamesFunctionPtr)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
  80     GetOwnNonIndexPropertyNamesFunctionPtr getOwnNonIndexPropertyNames;
  81
  82     typedef void (*GetPropertyNamesFunctionPtr)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
  83     GetPropertyNamesFunctionPtr getPropertyNames;
  84
  85     typedef String (*ClassNameFunctionPtr)(const JSObject*);
  86     ClassNameFunctionPtr className;
  87
  88     typedef bool (*CustomHasInstanceFunctionPtr)(JSObject*, ExecState*, JSValue);
  89     CustomHasInstanceFunctionPtr customHasInstance;
  90
  91     typedef bool (*DefineOwnPropertyFunctionPtr)(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool);
  92     DefineOwnPropertyFunctionPtr defineOwnProperty;
  93
  94     typedef ArrayBuffer* (*SlowDownAndWasteMemory)(JSArrayBufferView*);
  95     SlowDownAndWasteMemory slowDownAndWasteMemory;
  96
  97     typedef PassRefPtr<ArrayBufferView> (*GetTypedArrayImpl)(JSArrayBufferView*);
  98     GetTypedArrayImpl getTypedArrayImpl;
  99
 100     typedef void (*DumpToStreamFunctionPtr)(const JSCell*, PrintStream&);
 101     DumpToStreamFunctionPtr dumpToStream;
 102 };
 103
 104 #define CREATE_MEMBER_CHECKER(member) \
 105     template <typename T> \
 106     struct MemberCheck##member { \
 107         struct Fallback { \
 108             void member(...); \
 109         }; \
 110         struct Derived : T, Fallback { }; \
 111         template <typename U, U> struct Check; \
 112         typedef char Yes[2]; \
 113         typedef char No[1]; \
 114         template <typename U> \
 115         static No &func(Check<void (Fallback::*)(...), &U::member>*); \
 116         template <typename U> \
 117         static Yes &func(...); \
 118         enum { has = sizeof(func<Derived>(0)) == sizeof(Yes) }; \
 119     }
 120
 121 #define HAS_MEMBER_NAMED(klass, name) (MemberCheck##name<klass>::has)
 122
 123 #define CREATE_METHOD_TABLE(ClassName) { \
 124         &ClassName::destroy, \
 125         &ClassName::visitChildren, \
 126         &ClassName::copyBackingStore, \
 127         &ClassName::getCallData, \
 128         &ClassName::getConstructData, \
 129         &ClassName::put, \
 130         &ClassName::putByIndex, \
 131         &ClassName::deleteProperty, \
 132         &ClassName::deletePropertyByIndex, \
 133         &ClassName::getOwnPropertySlot, \
 134         &ClassName::getOwnPropertySlotByIndex, \
 135         &ClassName::toThis, \
 136         &ClassName::defaultValue, \
 137         &ClassName::getOwnPropertyNames, \
 138         &ClassName::getOwnNonIndexPropertyNames, \
 139         &ClassName::getPropertyNames, \
 140         &ClassName::className, \
 141         &ClassName::customHasInstance, \
 142         &ClassName::defineOwnProperty, \
 143         &ClassName::slowDownAndWasteMemory, \
 144         &ClassName::getTypedArrayImpl, \
 145         &ClassName::dumpToStream \
 146     }, \
 147     ClassName::TypedArrayStorageType
 148
 149 struct ClassInfo {
 150     // A string denoting the class name. Example: "Window".
 151     const char* className;
 152
 153     // Pointer to the class information of the base class.
 154     // nullptrif there is none.
 155     const ClassInfo* parentClass;
 156
 157     // Static hash-table of properties.
 158     // For classes that can be used from multiple threads, it is accessed via a getter function
 159     // that would typically return a pointer to a thread-specific value.
 160     const HashTable* propHashTable(ExecState* exec) const
 161     {
 162         if (classPropHashTableGetterFunction)
 163             return &classPropHashTableGetterFunction(exec->vm());
 164
 165         return staticPropHashTable;
 166     }
 167
 168     const HashTable* propHashTable(VM& vm) const
 169     {
 170         if (classPropHashTableGetterFunction)
 171             return &classPropHashTableGetterFunction(vm);
 172
 173         return staticPropHashTable;
 174     }
 175
 176     bool isSubClassOf(const ClassInfo* other) const
 177     {
 178         for (const ClassInfo* ci = this; ci; ci = ci->parentClass) {
 179             if (ci == other)
 180                 return true;
 181         }
 182         return false;
 183     }
 184
 185     bool hasStaticProperties() const
 186     {
 187         for (const ClassInfo* ci = this; ci; ci = ci->parentClass) {
 188             if (ci->staticPropHashTable || ci->classPropHashTableGetterFunction)
 189                 return true;
 190         }
 191         return false;
 192     }
 193
 194     bool hasStaticSetterOrReadonlyProperties(VM&) const;
 195
 196     const HashTable* staticPropHashTable;
 197     typedef const HashTable& (*ClassPropHashTableGetterFunction)(VM&);
 198     const ClassPropHashTableGetterFunction classPropHashTableGetterFunction;
 199
 200     MethodTable methodTable;
 201
 202     TypedArrayType typedArrayStorageType;
 203 };
 204
 205 } // namespace JSC
 206
 207 #endif // ClassInfo_h