Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 401 insertions, 0 deletions

diff --git a/kjs/lookup.h b/kjs/lookup.h
new file mode 100644
index 000000000..a77b0b633
--- /dev/null
+++ b/kjs/lookup.h
@@ -0,0 +1,401 @@
+// -*- c-basic-offset: 2 -*-
+/*
+ *  This file is part of the KDE libraries
+ *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
+ *  Copyright (C) 2003 Apple Computer, Inc.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef _KJSLOOKUP_H_
+#define _KJSLOOKUP_H_
+
+#include "identifier.h"
+#include "value.h"
+#include "object.h"
+#include "interpreter.h"
+#include <stdio.h>
+
+namespace KJS {
+
+  /**
+   * An entry in a hash table.
+   */
+  struct HashEntry {
+    /**
+     * s is the offset to the string key (e.g. a property name)
+     */
+    unsigned short soffset;
+    /**
+     * value is the result value (usually an enum value)
+     */
+    short int value;
+    /**
+     * attr is a set for flags (e.g. the property flags, see object.h)
+     */
+    unsigned char attr;
+    /**
+     * params is another number. For property hashtables, it is used to
+     * denote the number of argument of the function
+     */
+    unsigned char params;
+    /**
+     * next is the index to the next entry for the same hash value
+     */
+    short next;
+  };
+
+  /**
+   * A hash table
+   * Usually the hashtable is generated by the create_hash_table script, from a .table file.
+   *
+   * The implementation uses an array of entries, "size" is the total size of that array.
+   * The entries between 0 and hashSize-1 are the entry points
+   * for each hash value, and the entries between hashSize and size-1
+   * are the overflow entries for the hash values that need one.
+   * The "next" pointer of the entry links entry points to overflow entries,
+   * and links overflow entries between them.
+   */
+  struct HashTable {
+    /**
+     * type is a version number. Currently always 2
+     */
+    int type;
+    /**
+     * size is the total number of entries in the hashtable, including the null entries,
+     * i.e. the size of the "entries" array.
+     * Used to iterate over all entries in the table
+     */
+    int size;
+    /**
+     * pointer to the array of entries
+     * Mind that some entries in the array are null (0,0,0,0).
+     */
+    const HashEntry *const entries;
+    /**
+     * the maximum value for the hash. Always smaller than size.
+     */
+    int hashSize;
+
+    /**
+     * pointer to the string table.
+     */
+    const char* const sbase;
+  };
+
+  /**
+   * @short Fast keyword lookup.
+   */
+  class KJS_EXPORT Lookup {
+  public:
+    /**
+     * Find an entry in the table, and return its value (i.e. the value field of HashEntry)
+     */
+    static int find(const struct HashTable *table, const Identifier &s);
+    static int find(const struct HashTable *table,
+		    const UChar *c, unsigned int len);
+
+    /**
+     * Find an entry in the table, and return the entry
+     * This variant gives access to the other attributes of the entry,
+     * especially the attr field.
+     */
+    static const HashEntry* findEntry(const struct HashTable *table,
+                                      const Identifier &s);
+    static const HashEntry* findEntry(const struct HashTable *table,
+                                      const UChar *c, unsigned int len);
+
+    /**
+     * Calculate the hash value for a given key
+     */
+    static unsigned int hash(const Identifier &key);
+    static unsigned int hash(const UChar *c, unsigned int len);
+    static unsigned int hash(const char *s);
+  };
+
+  class ExecState;
+  class UString;
+  /**
+   * @internal
+   * Helper for lookupFunction and lookupValueOrFunction
+   */
+  template <class FuncImp>
+  inline Value lookupOrCreateFunction(ExecState *exec, const Identifier &propertyName,
+                                      const ObjectImp *thisObj, int token, int params, int attr)
+  {
+      // Look for cached value in dynamic map of properties (in ObjectImp)
+      ValueImp * cachedVal = thisObj->ObjectImp::getDirect(propertyName);
+      /*if (cachedVal)
+        fprintf(stderr, "lookupOrCreateFunction: Function -> looked up in ObjectImp, found type=%d\n", cachedVal->type());*/
+      if (cachedVal)
+        return Value(cachedVal);
+
+      ObjectImp* func = new FuncImp( exec, token, params );
+      Value val( func );
+      func->setFunctionName( propertyName );
+      ObjectImp *thatObj = const_cast<ObjectImp *>(thisObj);
+      thatObj->ObjectImp::put(exec, propertyName, val, attr);
+      return val;
+  }
+
+  /**
+   * Helper method for property lookups
+   *
+   * This method does it all (looking in the hashtable, checking for function
+   * overrides, creating the function or retrieving from cache, calling
+   * getValueProperty in case of a non-function property, forwarding to parent if
+   * unknown property).
+   *
+   * Template arguments:
+   *   - @c FuncImp the class which implements this object's functions
+   *   - @c ThisImp the class of "this". It must implement the 
+   *        getValueProperty(exec,token) method, for non-function properties.
+   *   - @c ParentImp the class of the parent, to propagate the lookup.
+   *
+   * Method arguments:
+   * @param exec execution state, as usual
+   * @param propertyName the property we're looking for
+   * @param table the static hashtable for this class
+   * @param thisObj "this"
+   */
+  template <class FuncImp, class ThisImp, class ParentImp>
+  inline Value lookupGet(ExecState *exec, const Identifier &propertyName,
+                         const HashTable* table, const ThisImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found, forward to parent
+      return thisObj->ParentImp::get(exec, propertyName);
+
+    //fprintf(stderr, "lookupGet: found value=%d attr=%d\n", entry->value, entry->attr);
+    if (entry->attr & Function)
+      return lookupOrCreateFunction<FuncImp>(exec, propertyName, thisObj, entry->value, entry->params, entry->attr);
+    return thisObj->getValueProperty(exec, entry->value);
+  }
+
+  /**
+   * Simplified version of lookupGet in case there are only functions.
+   * Using this instead of lookupGet prevents 'this' from implementing a dummy getValueProperty.
+   */
+  template <class FuncImp, class ParentImp>
+  inline Value lookupGetFunction(ExecState *exec, const Identifier &propertyName,
+                         const HashTable* table, const ObjectImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found, forward to parent
+      return static_cast<const ParentImp *>(thisObj)->ParentImp::get(exec, propertyName);
+
+    if (entry->attr & Function)
+      return lookupOrCreateFunction<FuncImp>(exec, propertyName, thisObj, entry->value, entry->params, entry->attr);
+
+    fprintf(stderr, "Function bit not set! Shouldn't happen in lookupGetFunction!\n" );
+    return Undefined();
+  }
+
+  /**
+   * Simplified version of lookupGet in case there are no functions, only "values".
+   * Using this instead of lookupGet removes the need for a FuncImp class.
+   */
+  template <class ThisImp, class ParentImp>
+  inline Value lookupGetValue(ExecState *exec, const Identifier &propertyName,
+                           const HashTable* table, const ThisImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found, forward to parent
+      return thisObj->ParentImp::get(exec, propertyName);
+
+    if (entry->attr & Function)
+      fprintf(stderr, "Function bit set! Shouldn't happen in lookupGetValue! propertyName was %s\n", propertyName.ascii() );
+    return thisObj->getValueProperty(exec, entry->value);
+  }
+
+  /**
+   * This one is for "put".
+   * Lookup hash entry for property to be set, and set the value.
+   */
+  template <class ThisImp, class ParentImp>
+  inline void lookupPut(ExecState *exec, const Identifier &propertyName,
+                        const Value& value, int attr,
+                        const HashTable* table, ThisImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found: forward to parent
+      thisObj->ParentImp::put(exec, propertyName, value, attr);
+    else if (entry->attr & Function) // function: put as override property
+      thisObj->ObjectImp::put(exec, propertyName, value, attr);
+    else if (entry->attr & ReadOnly) // readonly! Can't put!
+#ifdef KJS_VERBOSE
+      fprintf(stderr,"WARNING: Attempt to change value of readonly property '%s'\n",propertyName.ascii());
+#else
+      ; // do nothing
+#endif
+    else
+      thisObj->putValueProperty(exec, entry->value, value, attr);
+  }
+
+
+  /**
+   * This template method retrieves or create an object that is unique
+   * (for a given interpreter) The first time this is called (for a given
+   * property name), the Object will be constructed, and set as a property
+   * of the interpreter's global object. Later calls will simply retrieve
+   * that cached object. Note that the object constructor must take 1 argument, exec.
+   */
+  template <class ClassCtor>
+  inline KJS::Object cacheGlobalObject(ExecState *exec, const Identifier &propertyName)
+  {
+    ValueImp *obj = static_cast<KJS::ObjectImp*>(exec->interpreter()->globalObject().imp())->getDirect(propertyName);
+    if (obj)
+      return KJS::Object::dynamicCast(Value(obj));
+    else
+    {
+      KJS::Object newObject(new ClassCtor(exec));
+      exec->interpreter()->globalObject().put(exec, propertyName, newObject, Internal);
+      return newObject;
+    }
+  }
+
+
+  /**
+   * Helpers to define prototype objects (each of which simply implements
+   * the functions for a type of objects).
+   * Sorry for this not being very readable, but it actually saves much copy-n-paste.
+   * ParentProto is not our base class, it's the object we use as fallback.
+   * The reason for this is that there should only be ONE DOMNode.hasAttributes (e.g.),
+   * not one in each derived class. So we link the (unique) prototypes between them.
+   *
+   * Using those macros is very simple: define the hashtable (e.g. "DOMNodeProtoTable"), then
+   * DEFINE_PROTOTYPE("DOMNode",DOMNodeProto)
+   * IMPLEMENT_PROTOFUNC(DOMNodeProtoFunc)
+   * IMPLEMENT_PROTOTYPE(DOMNodeProto,DOMNodeProtoFunc)
+   * and use DOMNodeProto::self(exec) as prototype in the DOMNode constructor.
+   * If the prototype has a "parent prototype", e.g. DOMElementProto falls back on DOMNodeProto,
+   * then the last line will use IMPLEMENT_PROTOTYPE_WITH_PARENT, with DOMNodeProto as last argument.
+   * PUBLIC_DEFINE_PROTOTYPE and PUBLIC_IMPLEMENT_PROTOTYPE are versions with support for separate compilation
+   */
+
+#define PUBLIC_DEFINE_PROTOTYPE(ClassName,ClassProto) \
+  namespace KJS { \
+  class ClassProto : public KJS::ObjectImp { \
+    friend KJS::Object cacheGlobalObject<ClassProto>(KJS::ExecState *exec, const KJS::Identifier &propertyName); \
+  public: \
+    static KJS::Object self(KJS::ExecState *exec) \
+    { \
+      return cacheGlobalObject<ClassProto>( exec, "[[" ClassName ".prototype]]" ); \
+    } \
+  protected: \
+    ClassProto( KJS::ExecState *exec ) \
+      : KJS::ObjectImp( exec->interpreter()->builtinObjectPrototype() ) {} \
+    \
+  public: \
+    virtual const KJS::ClassInfo *classInfo() const { return &info; } \
+    static const KJS::ClassInfo info; \
+    KJS::Value get(KJS::ExecState *exec, const KJS::Identifier &propertyName) const; \
+    bool hasProperty(KJS::ExecState *exec, const KJS::Identifier &propertyName) const; \
+  }; \
+  }
+
+#define IMPLEMENT_CLASSINFO(ClassName,ClassProto) \
+  namespace KJS {\
+  const KJS::ClassInfo ClassProto::info = { ClassName, 0, &ClassProto##Table, 0 }; \
+  }
+
+#define DEFINE_PROTOTYPE(ClassName,ClassProto) \
+  PUBLIC_DEFINE_PROTOTYPE(ClassName,ClassProto) \
+  IMPLEMENT_CLASSINFO(ClassName,ClassProto)
+
+#define IMPLEMENT_PROTOTYPE(ClassProto,ClassFunc) \
+    KJS::Value KJS::ClassProto::get(KJS::ExecState *exec, const KJS::Identifier &propertyName) const \
+    { \
+      /*fprintf( stderr, "%sProto::get(%s) [in macro, no parent]\n", info.className, propertyName.ascii());*/ \
+      return lookupGetFunction<ClassFunc,KJS::ObjectImp>(exec, propertyName, &ClassProto##Table, this ); \
+    } \
+    bool KJS::ClassProto::hasProperty(KJS::ExecState *exec, const KJS::Identifier &propertyName) const \
+    { /*stupid but we need this to have a common macro for the declaration*/ \
+      return KJS::ObjectImp::hasProperty(exec, propertyName); \
+    }
+
+#define PUBLIC_IMPLEMENT_PROTOTYPE(ClassProto,ClassName,ClassFunc) \
+    IMPLEMENT_PROTOTYPE(ClassProto,ClassFunc)\
+    IMPLEMENT_CLASSINFO(ClassName,ClassProto)
+
+#define IMPLEMENT_PROTOTYPE_WITH_PARENT(ClassProto,ClassFunc,ParentProto)  \
+    KJS::Value KJS::ClassProto::get(KJS::ExecState *exec, const KJS::Identifier &propertyName) const \
+    { \
+      /*fprintf( stderr, "%sProto::get(%s) [in macro]\n", info.className, propertyName.ascii());*/ \
+      KJS::Value val = lookupGetFunction<ClassFunc,KJS::ObjectImp>(exec, propertyName, &ClassProto##Table, this ); \
+      if ( val.type() != UndefinedType ) return val; \
+      /* Not found -> forward request to "parent" prototype */ \
+      return ParentProto::self(exec).get( exec, propertyName ); \
+    } \
+    bool KJS::ClassProto::hasProperty(KJS::ExecState *exec, const KJS::Identifier &propertyName) const \
+    { \
+      if (KJS::ObjectImp::hasProperty(exec, propertyName)) \
+        return true; \
+      return ParentProto::self(exec).hasProperty(exec, propertyName); \
+    }
+    
+#define PUBLIC_IMPLEMENT_PROTOTYPE_WITH_PARENT(ClassProto,ClassName,ClassFunc,ParentProto)  \
+    IMPLEMENT_PROTOTYPE_WITH_PARENT(ClassProto,ClassFunc,ParentProto) \
+    IMPLEMENT_CLASSINFO(ClassName,ClassProto)
+
+#define IMPLEMENT_PROTOFUNC(ClassFunc) \
+  namespace KJS { \
+  class ClassFunc : public ObjectImp { \
+  public: \
+    ClassFunc(KJS::ExecState *exec, int i, int len) \
+       : ObjectImp( /*proto? */ ), id(i) { \
+       KJS::Value protect(this); \
+       put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum); \
+    } \
+    virtual bool implementsCall() const { return true; } \
+    /** You need to implement that one */ \
+    virtual KJS::Value call(KJS::ExecState *exec, KJS::Object &thisObj, const KJS::List &args); \
+  private: \
+    int id; \
+  }; \
+  }
+
+  // To be used in all call() implementations, before casting the type of thisObj
+#define KJS_CHECK_THIS( ClassName, theObj ) \
+  if (!theObj.isValid() || !theObj.inherits(&ClassName::info)) { \
+    KJS::UString errMsg = "Attempt at calling a function that expects a "; \
+    errMsg += ClassName::info.className; \
+    errMsg += " on a "; \
+    errMsg += thisObj.className(); \
+    KJS::Object err = KJS::Error::create(exec, KJS::TypeError, errMsg.ascii()); \
+    exec->setException(err); \
+    return err; \
+  }
+
+  /*
+   * List of things to do when porting an objectimp to the 'static hashtable' mechanism:
+   * - write the hashtable source, between @begin and @end
+   * - add a rule to build the .lut.h
+   * - include the .lut.h
+   * - mention the table in the classinfo (add a classinfo if necessary)
+   * - write/update the class enum (for the tokens)
+   * - turn get() into getValueProperty(), put() into putValueProperty(), using a switch and removing funcs
+   * - write get() and/or put() using a template method
+   * - cleanup old stuff (e.g. hasProperty)
+   * - compile, test, commit ;)
+   */
+} // namespace
+
+#endif