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*, const Identifier&);
 107     static int find(const struct HashTable*, const UChar*, unsigned int len);
 108
 109
 110     /**
 111      * Find an entry in the table, and return the entry
 112      * This variant gives access to the other attributes of the entry,
 113      * especially the attr field.
 114      */
 115     static const HashEntry* findEntry(const struct HashTable*, const Identifier&);
 116
 117   };
 118
 119   class ExecState;
 120   class UString;
 121   /**
 122    * @internal
 123    * Helper for getStaticFunctionSlot and getStaticPropertySlot
 124    */
 125   template <class FuncImp>
 126   inline JSValue* staticFunctionGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
 127   {
 128       // Look for cached value in dynamic map of properties (in JSObject)
 129       JSObject* thisObj = slot.slotBase();
 130       JSValue* cachedVal = thisObj->getDirect(propertyName);
 131       if (cachedVal)
 132         return cachedVal;
 133
 134       const HashEntry* entry = slot.staticEntry();
 135       JSValue* val = new FuncImp(exec, entry->value, entry->params, propertyName);
 136       thisObj->putDirect(propertyName, val, entry->attr);
 137       return val;
 138   }
 139
 140   /**
 141    * @internal
 142    * Helper for getStaticValueSlot and getStaticPropertySlot
 143    */
 144   template <class ThisImp>
 145   inline JSValue* staticValueGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)
 146   {
 147       ThisImp* thisObj = static_cast<ThisImp*>(slot.slotBase());
 148       const HashEntry* entry = slot.staticEntry();
 149       return thisObj->getValueProperty(exec, entry->value);
 150   }
 151
 152   /**
 153    * Helper method for property lookups
 154    *
 155    * This method does it all (looking in the hashtable, checking for function
 156    * overrides, creating the function or retrieving from cache, calling
 157    * getValueProperty in case of a non-function property, forwarding to parent if
 158    * unknown property).
 159    *
 160    * Template arguments:
 161    * @param FuncImp the class which implements this object's functions
 162    * @param ThisImp the class of "this". It must implement the getValueProperty(exec,token) method,
 163    * for non-function properties.
 164    * @param ParentImp the class of the parent, to propagate the lookup.
 165    *
 166    * Method arguments:
 167    * @param exec execution state, as usual
 168    * @param propertyName the property we're looking for
 169    * @param table the static hashtable for this class
 170    * @param thisObj "this"
 171    */
 172   template <class FuncImp, class ThisImp, class ParentImp>
 173   inline bool getStaticPropertySlot(ExecState* exec, const HashTable* table,
 174                                     ThisImp* thisObj, const Identifier& propertyName, PropertySlot& slot)
 175   {
 176     const HashEntry* entry = Lookup::findEntry(table, propertyName);
 177
 178     if (!entry) // not found, forward to parent
 179       return thisObj->ParentImp::getOwnPropertySlot(exec, propertyName, slot);
 180
 181     if (entry->attr & Function)
 182       slot.setStaticEntry(thisObj, entry, staticFunctionGetter<FuncImp>);
 183     else
 184       slot.setStaticEntry(thisObj, entry, staticValueGetter<ThisImp>);
 185
 186     return true;
 187   }
 188
 189   /**
 190    * Simplified version of getStaticPropertySlot in case there are only functions.
 191    * Using this instead of getStaticPropertySlot allows 'this' to avoid implementing
 192    * a dummy getValueProperty.
 193    */
 194   template <class FuncImp, class ParentImp>
 195   inline bool getStaticFunctionSlot(ExecState* exec, const HashTable* table,
 196                                     JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot)
 197   {
 198     const HashEntry* entry = Lookup::findEntry(table, propertyName);
 199
 200     if (!entry) // not found, forward to parent
 201       return static_cast<ParentImp*>(thisObj)->ParentImp::getOwnPropertySlot(exec, propertyName, slot);
 202
 203     assert(entry->attr & Function);
 204
 205     slot.setStaticEntry(thisObj, entry, staticFunctionGetter<FuncImp>);
 206     return true;
 207   }
 208
 209   /**
 210    * Simplified version of getStaticPropertySlot in case there are no functions, only "values".
 211    * Using this instead of getStaticPropertySlot removes the need for a FuncImp class.
 212    */
 213   template <class ThisImp, class ParentImp>
 214   inline bool getStaticValueSlot(ExecState* exec, const HashTable* table,
 215                                  ThisImp* thisObj, const Identifier& propertyName, PropertySlot& slot)
 216   {
 217     const HashEntry* entry = Lookup::findEntry(table, propertyName);
 218
 219     if (!entry) // not found, forward to parent
 220       return thisObj->ParentImp::getOwnPropertySlot(exec, propertyName, slot);
 221
 222     assert(!(entry->attr & Function));
 223
 224     slot.setStaticEntry(thisObj, entry, staticValueGetter<ThisImp>);
 225     return true;
 226   }
 227
 228   /**
 229    * This one is for "put".
 230    * It looks up a hash entry for the property to be set.  If an entry
 231    * is found it sets the value and returns true, else it returns false.
 232    */
 233   template <class ThisImp>
 234   inline bool lookupPut(ExecState* exec, const Identifier& propertyName,
 235                         JSValue* value, int attr,
 236                         const HashTable* table, ThisImp* thisObj)
 237   {
 238     const HashEntry* entry = Lookup::findEntry(table, propertyName);
 239
 240     if (!entry)
 241       return false;
 242
 243     if (entry->attr & Function) // function: put as override property
 244       thisObj->JSObject::put(exec, propertyName, value, attr);
 245     else if (entry->attr & ReadOnly) // readonly! Can't put!
 246 #ifdef KJS_VERBOSE
 247       fprintf(stderr,"WARNING: Attempt to change value of readonly property '%s'\n",propertyName.ascii());
 248 #else
 249       ; // do nothing
 250 #endif
 251     else
 252       thisObj->putValueProperty(exec, entry->value, value, attr);
 253
 254     return true;
 255   }
 256
 257   /**
 258    * This one is for "put".
 259    * It calls lookupPut<ThisImp>() to set the value.  If that call
 260    * returns false (meaning no entry in the hash table was found),
 261    * then it calls put() on the ParentImp class.
 262    */
 263   template <class ThisImp, class ParentImp>
 264   inline void lookupPut(ExecState* exec, const Identifier& propertyName,
 265                         JSValue* value, int attr,
 266                         const HashTable* table, ThisImp* thisObj)
 267   {
 268     if (!lookupPut<ThisImp>(exec, propertyName, value, attr, table, thisObj))
 269       thisObj->ParentImp::put(exec, propertyName, value, attr); // not found: forward to parent
 270   }
 271
 272   /**
 273    * This template method retrieves or create an object that is unique
 274    * (for a given interpreter) The first time this is called (for a given
 275    * property name), the Object will be constructed, and set as a property
 276    * of the interpreter's global object. Later calls will simply retrieve
 277    * that cached object. Note that the object constructor must take 1 argument, exec.
 278    */
 279   template <class ClassCtor>
 280   inline JSObject* cacheGlobalObject(ExecState* exec, const Identifier& propertyName)
 281   {
 282     JSObject* globalObject = static_cast<JSObject*>(exec->lexicalInterpreter()->globalObject());
 283     JSValue* obj = globalObject->getDirect(propertyName);
 284     if (obj) {
 285       assert(obj->isObject());
 286       return static_cast<JSObject* >(obj);
 287     }
 288     JSObject* newObject = new ClassCtor(exec);
 289     globalObject->put(exec, propertyName, newObject, Internal | DontEnum);
 290     return newObject;
 291   }
 292
 293 } // namespace
 294
 295 /**
 296  * Helpers to define prototype objects (each of which simply implements
 297  * the functions for a type of objects).
 298  * Sorry for this not being very readable, but it actually saves much copy-n-paste.
 299  * ParentProto is not our base class, it's the object we use as fallback.
 300  * The reason for this is that there should only be ONE DOMNode.hasAttributes (e.g.),
 301  * not one in each derived class. So we link the (unique) prototypes between them.
 302  *
 303  * Using those macros is very simple: define the hashtable (e.g. "DOMNodeProtoTable"), then
 304  * KJS_DEFINE_PROTOTYPE(DOMNodeProto)
 305  * KJS_IMPLEMENT_PROTOFUNC(DOMNodeProtoFunc)
 306  * KJS_IMPLEMENT_PROTOTYPE("DOMNode", DOMNodeProto,DOMNodeProtoFunc)
 307  * and use DOMNodeProto::self(exec) as prototype in the DOMNode constructor.
 308  * If the prototype has a "parent prototype", e.g. DOMElementProto falls back on DOMNodeProto,
 309  * then the first line will use KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE, with DOMNodeProto as the second argument.
 310  */
 311
 312 // These macros assume that a prototype's only properties are functions
 313 #define KJS_DEFINE_PROTOTYPE(ClassProto) \
 314   class ClassProto : public KJS::JSObject { \
 315   public: \
 316     static KJS::JSObject* self(KJS::ExecState* exec); \
 317     virtual const KJS::ClassInfo* classInfo() const { return &info; } \
 318     static const KJS::ClassInfo info; \
 319     bool getOwnPropertySlot(KJS::ExecState* , const KJS::Identifier&, KJS::PropertySlot&); \
 320     ClassProto(KJS::ExecState* exec) \
 321       : KJS::JSObject(exec->lexicalInterpreter()->builtinObjectPrototype()) { } \
 322     \
 323   };
 324
 325 #define KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(ClassProto, ClassProtoProto) \
 326     class ClassProto : public KJS::JSObject { \
 327     public: \
 328         static KJS::JSObject* self(KJS::ExecState* exec); \
 329         virtual const KJS::ClassInfo* classInfo() const { return &info; } \
 330         static const KJS::ClassInfo info; \
 331         bool getOwnPropertySlot(KJS::ExecState*, const KJS::Identifier&, KJS::PropertySlot&); \
 332         ClassProto(KJS::ExecState* exec) \
 333             : KJS::JSObject(ClassProtoProto::self(exec)) { } \
 334     \
 335     };
 336
 337 #define KJS_IMPLEMENT_PROTOTYPE(ClassName, ClassProto, ClassFunc) \
 338     const ClassInfo ClassProto::info = { ClassName, 0, &ClassProto##Table, 0 }; \
 339     JSObject* ClassProto::self(ExecState* exec) \
 340     { \
 341         return KJS::cacheGlobalObject<ClassProto>(exec, "[[" ClassName ".prototype]]"); \
 342     } \
 343     bool ClassProto::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) \
 344     { \
 345       return getStaticFunctionSlot<ClassFunc, JSObject>(exec, &ClassProto##Table, this, propertyName, slot); \
 346     }
 347
 348 #define KJS_IMPLEMENT_PROTOFUNC(ClassFunc) \
 349   class ClassFunc : public InternalFunctionImp { \
 350   public: \
 351     ClassFunc(ExecState* exec, int i, int len, const Identifier& name) \
 352       : InternalFunctionImp(static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype()), name) \
 353       , id(i) \
 354     { \
 355        put(exec, lengthPropertyName, jsNumber(len), DontDelete|ReadOnly|DontEnum); \
 356     } \
 357     /* Macro user needs to implement the callAsFunction function. */ \
 358     virtual JSValue* callAsFunction(ExecState* exec, JSObject* thisObj, const List& args); \
 359   private: \
 360     int id; \
 361   };
 362
 363 #endif