55506f0e2f2fa9752ca519c151298cf0f58d8aa2
[WebKit-https.git] / JavaScriptCore / kjs / lookup.h
1 // -*- c-basic-offset: 2 -*-
2 /*
3  *  This file is part of the KDE libraries
4  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
5  *  Copyright (C) 2003 Apple Computer, Inc.
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public
18  *  License along with this library; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  *
21  */
22
23 #ifndef _KJSLOOKUP_H_
24 #define _KJSLOOKUP_H_
25
26 #include "interpreter.h"
27 #include "internal.h"
28 #include "identifier.h"
29 #include "function_object.h"
30 #include "object.h"
31 #include <stdio.h>
32
33 namespace KJS {
34
35   class FunctionPrototype;
36
37   /**
38    * An entry in a hash table.
39    */
40   struct HashEntry {
41     /**
42      * s is the key (e.g. a property name)
43      */
44     const char *s;
45
46     /**
47      * value is the result value (usually an enum value)
48      */
49     int value;
50     /**
51      * attr is a set for flags (e.g. the property flags, see object.h)
52      */
53     short int attr;
54     /**
55      * params is another number. For property hashtables, it is used to
56      * denote the number of argument of the function
57      */
58     short int params;
59     /**
60      * next is the pointer to the next entry for the same hash value
61      */
62     const HashEntry *next;
63   };
64
65   /**
66    * A hash table
67    * Usually the hashtable is generated by the create_hash_table script, from a .table file.
68    *
69    * The implementation uses an array of entries, "size" is the total size of that array.
70    * The entries between 0 and hashSize-1 are the entry points
71    * for each hash value, and the entries between hashSize and size-1
72    * are the overflow entries for the hash values that need one.
73    * The "next" pointer of the entry links entry points to overflow entries,
74    * and links overflow entries between them.
75    */
76   struct HashTable {
77     /**
78      * type is a version number. Currently always 2
79      */
80     int type;
81     /**
82      * size is the total number of entries in the hashtable, including the null entries,
83      * i.e. the size of the "entries" array.
84      * Used to iterate over all entries in the table
85      */
86     int size;
87     /**
88      * pointer to the array of entries
89      * Mind that some entries in the array are null (0,0,0,0).
90      */
91     const HashEntry *entries;
92     /**
93      * the maximum value for the hash. Always smaller than size.
94      */
95     int hashSize;
96   };
97
98   /**
99    * @short Fast keyword lookup.
100    */
101   class Lookup {
102   public:
103     /**
104      * Find an entry in the table, and return its value (i.e. the value field of HashEntry)
105      */
106     static int find(const struct HashTable *table, const Identifier &s);
107     static int find(const struct HashTable *table,
108                     const UChar *c, unsigned int len);
109
110
111     /**
112      * Find an entry in the table, and return the entry
113      * This variant gives access to the other attributes of the entry,
114      * especially the attr field.
115      */
116     static const HashEntry* findEntry(const struct HashTable *table,
117                                       const Identifier &s);
118
119   };
120
121   class ExecState;
122   class UString;
123   /**
124    * @internal
125    * Helper for getStaticFunctionSlot and getStaticPropertySlot
126    */
127   template <class FuncImp>
128   inline JSValue *staticFunctionGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
129   {
130       // Look for cached value in dynamic map of properties (in JSObject)
131       JSObject *thisObj = slot.slotBase();
132       JSValue *cachedVal = thisObj->getDirect(propertyName);
133       if (cachedVal)
134         return cachedVal;
135
136       const HashEntry *entry = slot.staticEntry();
137       JSValue *val = new FuncImp(exec, entry->value, entry->params, propertyName);
138       thisObj->putDirect(propertyName, val, entry->attr);
139       return val;
140   }
141
142   /**
143    * @internal
144    * Helper for getStaticValueSlot and getStaticPropertySlot
145    */
146   template <class ThisImp>
147   inline JSValue *staticValueGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)
148   {
149       ThisImp* thisObj = static_cast<ThisImp*>(slot.slotBase());
150       const HashEntry* entry = slot.staticEntry();
151       return thisObj->getValueProperty(exec, entry->value);
152   }
153
154   /**
155    * Helper method for property lookups
156    *
157    * This method does it all (looking in the hashtable, checking for function
158    * overrides, creating the function or retrieving from cache, calling
159    * getValueProperty in case of a non-function property, forwarding to parent if
160    * unknown property).
161    *
162    * Template arguments:
163    * @param FuncImp the class which implements this object's functions
164    * @param ThisImp the class of "this". It must implement the getValueProperty(exec,token) method,
165    * for non-function properties.
166    * @param ParentImp the class of the parent, to propagate the lookup.
167    *
168    * Method arguments:
169    * @param exec execution state, as usual
170    * @param propertyName the property we're looking for
171    * @param table the static hashtable for this class
172    * @param thisObj "this"
173    */
174   template <class FuncImp, class ThisImp, class ParentImp>
175   inline bool getStaticPropertySlot(ExecState *exec, const HashTable* table, 
176                                     ThisImp* thisObj, const Identifier& propertyName, PropertySlot& slot)
177   {
178     const HashEntry* entry = Lookup::findEntry(table, propertyName);
179
180     if (!entry) // not found, forward to parent
181       return thisObj->ParentImp::getOwnPropertySlot(exec, propertyName, slot);
182
183     if (entry->attr & Function)
184       slot.setStaticEntry(thisObj, entry, staticFunctionGetter<FuncImp>);
185     else 
186       slot.setStaticEntry(thisObj, entry, staticValueGetter<ThisImp>);
187
188     return true;
189   }
190
191   /**
192    * Simplified version of getStaticPropertySlot in case there are only functions.
193    * Using this instead of getStaticPropertySlot allows 'this' to avoid implementing 
194    * a dummy getValueProperty.
195    */
196   template <class FuncImp, class ParentImp>
197   inline bool getStaticFunctionSlot(ExecState *exec, const HashTable *table, 
198                                     JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot)
199   {
200     const HashEntry* entry = Lookup::findEntry(table, propertyName);
201
202     if (!entry) // not found, forward to parent
203       return static_cast<ParentImp *>(thisObj)->ParentImp::getOwnPropertySlot(exec, propertyName, slot);
204
205     assert(entry->attr & Function);
206
207     slot.setStaticEntry(thisObj, entry, staticFunctionGetter<FuncImp>);
208     return true;
209   }
210
211   /**
212    * Simplified version of getStaticPropertySlot in case there are no functions, only "values".
213    * Using this instead of getStaticPropertySlot removes the need for a FuncImp class.
214    */
215   template <class ThisImp, class ParentImp>
216   inline bool getStaticValueSlot(ExecState *exec, const HashTable* table, 
217                                  ThisImp* thisObj, const Identifier &propertyName, PropertySlot& slot)
218   {
219     const HashEntry* entry = Lookup::findEntry(table, propertyName);
220
221     if (!entry) // not found, forward to parent
222       return thisObj->ParentImp::getOwnPropertySlot(exec, propertyName, slot);
223
224     assert(!(entry->attr & Function));
225
226     slot.setStaticEntry(thisObj, entry, staticValueGetter<ThisImp>);
227     return true;
228   }
229
230   /**
231    * This one is for "put".
232    * It looks up a hash entry for the property to be set.  If an entry
233    * is found it sets the value and returns true, else it returns false.
234    */
235   template <class ThisImp>
236   inline bool lookupPut(ExecState* exec, const Identifier &propertyName,
237                         JSValue* value, int attr,
238                         const HashTable* table, ThisImp* thisObj)
239   {
240     const HashEntry* entry = Lookup::findEntry(table, propertyName);
241
242     if (!entry)
243       return false;
244
245     if (entry->attr & Function) // function: put as override property
246       thisObj->JSObject::put(exec, propertyName, value, attr);
247     else if (entry->attr & ReadOnly) // readonly! Can't put!
248 #ifdef KJS_VERBOSE
249       fprintf(stderr,"WARNING: Attempt to change value of readonly property '%s'\n",propertyName.ascii());
250 #else
251       ; // do nothing
252 #endif
253     else
254       thisObj->putValueProperty(exec, entry->value, value, attr);
255
256     return true;
257   }
258
259   /**
260    * This one is for "put".
261    * It calls lookupPut<ThisImp>() to set the value.  If that call
262    * returns false (meaning no entry in the hash table was found),
263    * then it calls put() on the ParentImp class.
264    */
265   template <class ThisImp, class ParentImp>
266   inline void lookupPut(ExecState* exec, const Identifier &propertyName,
267                         JSValue* value, int attr,
268                         const HashTable* table, ThisImp* thisObj)
269   {
270     if (!lookupPut<ThisImp>(exec, propertyName, value, attr, table, thisObj))
271       thisObj->ParentImp::put(exec, propertyName, value, attr); // not found: forward to parent
272   }
273
274 } // namespace
275
276 /*
277  * The template method below can't be in the KJS namespace because it's used in 
278  * KJS_DEFINE_PROPERTY which can be used outside of the KJS namespace. It can be moved back
279  * when a gcc with http://gcc.gnu.org/bugzilla/show_bug.cgi?id=8355 is mainstream enough.
280  */
281  
282 /**
283  * This template method retrieves or create an object that is unique
284  * (for a given interpreter) The first time this is called (for a given
285  * property name), the Object will be constructed, and set as a property
286  * of the interpreter's global object. Later calls will simply retrieve
287  * that cached object. Note that the object constructor must take 1 argument, exec.
288  */
289 template <class ClassCtor>
290 inline KJS::JSObject *cacheGlobalObject(KJS::ExecState *exec, const KJS::Identifier &propertyName)
291 {
292   KJS::JSObject *globalObject = static_cast<KJS::JSObject *>(exec->lexicalInterpreter()->globalObject());
293   KJS::JSValue *obj = globalObject->getDirect(propertyName);
294   if (obj) {
295     assert(obj->isObject());
296     return static_cast<KJS::JSObject *>(obj);
297   }
298   KJS::JSObject *newObject = new ClassCtor(exec);
299   globalObject->put(exec, propertyName, newObject, KJS::Internal | KJS::DontEnum);
300   return newObject;
301 }
302
303 /**
304  * Helpers to define prototype objects (each of which simply implements
305  * the functions for a type of objects).
306  * Sorry for this not being very readable, but it actually saves much copy-n-paste.
307  * ParentProto is not our base class, it's the object we use as fallback.
308  * The reason for this is that there should only be ONE DOMNode.hasAttributes (e.g.),
309  * not one in each derived class. So we link the (unique) prototypes between them.
310  *
311  * Using those macros is very simple: define the hashtable (e.g. "DOMNodeProtoTable"), then
312  * KJS_DEFINE_PROTOTYPE(DOMNodeProto)
313  * KJS_IMPLEMENT_PROTOFUNC(DOMNodeProtoFunc)
314  * KJS_IMPLEMENT_PROTOTYPE("DOMNode", DOMNodeProto,DOMNodeProtoFunc)
315  * and use DOMNodeProto::self(exec) as prototype in the DOMNode constructor.
316  * If the prototype has a "parent prototype", e.g. DOMElementProto falls back on DOMNodeProto,
317  * then the first line will use KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE, with DOMNodeProto as the second argument.
318  */
319
320 // Work around a bug in GCC 4.1
321 #if !COMPILER(GCC)
322 #define KJS_GCC_ROOT_NS_HACK ::
323 #else
324 #define KJS_GCC_ROOT_NS_HACK
325 #endif
326
327 // These macros assume that a prototype's only properties are functions
328 #define KJS_DEFINE_PROTOTYPE(ClassProto) \
329   class ClassProto : public KJS::JSObject { \
330   friend KJS::JSObject *KJS_GCC_ROOT_NS_HACK cacheGlobalObject<ClassProto>(KJS::ExecState *exec, const KJS::Identifier &propertyName); \
331   public: \
332     static KJS::JSObject *self(KJS::ExecState *exec); \
333     virtual const KJS::ClassInfo *classInfo() const { return &info; } \
334     static const KJS::ClassInfo info; \
335     bool getOwnPropertySlot(KJS::ExecState *, const KJS::Identifier&, KJS::PropertySlot&); \
336   protected: \
337     ClassProto(KJS::ExecState *exec) \
338       : KJS::JSObject(exec->lexicalInterpreter()->builtinObjectPrototype()) { } \
339     \
340   };
341
342 #define KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(ClassProto, ClassProtoProto) \
343     class ClassProto : public KJS::JSObject { \
344         friend KJS::JSObject* KJS_GCC_ROOT_NS_HACK cacheGlobalObject<ClassProto>(KJS::ExecState* exec, const KJS::Identifier& propertyName); \
345     public: \
346         static KJS::JSObject* self(KJS::ExecState* exec); \
347         virtual const KJS::ClassInfo* classInfo() const { return &info; } \
348         static const KJS::ClassInfo info; \
349         bool getOwnPropertySlot(KJS::ExecState*, const KJS::Identifier&, KJS::PropertySlot&); \
350     protected: \
351         ClassProto(KJS::ExecState* exec) \
352             : KJS::JSObject(ClassProtoProto::self(exec)) { } \
353     \
354     };
355
356 #define KJS_IMPLEMENT_PROTOTYPE(ClassName, ClassProto, ClassFunc) \
357     const ClassInfo ClassProto::info = { ClassName, 0, &ClassProto##Table, 0 }; \
358     JSObject *ClassProto::self(ExecState *exec) \
359     { \
360         return ::cacheGlobalObject<ClassProto>(exec, "[[" ClassName ".prototype]]"); \
361     } \
362     bool ClassProto::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot) \
363     { \
364       return getStaticFunctionSlot<ClassFunc, JSObject>(exec, &ClassProto##Table, this, propertyName, slot); \
365     }
366
367 #define KJS_IMPLEMENT_PROTOFUNC(ClassFunc) \
368   class ClassFunc : public InternalFunctionImp { \
369   public: \
370     ClassFunc(ExecState* exec, int i, int len, const Identifier& name) \
371       : InternalFunctionImp(static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype()), name) \
372       , id(i) \
373     { \
374        put(exec, lengthPropertyName, jsNumber(len), DontDelete|ReadOnly|DontEnum); \
375     } \
376     /* Macro user needs to implement the callAsFunction function. */ \
377     virtual JSValue *callAsFunction(ExecState *exec, JSObject *thisObj, const List &args); \
378   private: \
379     int id; \
380   };
381
382 /*
383  * List of things to do when porting an objectimp to the 'static hashtable' mechanism:
384  * - write the hashtable source, between @begin and @end
385  * - add a rule to build the .lut.h
386  * - include the .lut.h
387  * - mention the table in the classinfo (add a classinfo if necessary)
388  * - write/update the class enum (for the tokens)
389  * - turn get() into getValueProperty(), put() into putValueProperty(), using a switch and removing funcs
390  * - write get() and/or put() using a template method
391  * - cleanup old stuff (e.g. hasProperty)
392  * - compile, test, commit ;)
393  */
394
395
396 #endif