// -*- c-basic-offset: 2 -*-

/*

 *  This file is part of the KDE libraries

 *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)

 *  Copyright (C) 2001 Peter Kelly (pmk@post.com)

 *  Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Library 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

 *  Library General Public License for more details.

 *

 *  You should have received a copy of the GNU Library General Public License

 *  along with this library; see the file COPYING.LIB.  If not, write to

 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 *  Boston, MA 02110-1301, USA.

 *

 */

#ifndef KJS_OBJECT_H

#define KJS_OBJECT_H

#include "JSType.h"

#include "CommonIdentifiers.h"

#include "interpreter.h"

#include "property_map.h"

#include "property_slot.h"

#include "scope_chain.h"

#include <wtf/AlwaysInline.h>

#if PLATFORM(SYMBIAN)

#include "collector.h"

#endif // PLATFORM(SYMBIAN)

namespace KJS {

  class InternalFunctionImp;

  class PropertyNameArray;

  struct HashEntry;

  struct HashTable;

  // ECMA 262-3 8.6.1

  // Property attributes

  enum Attribute { None         = 0,

                   ReadOnly     = 1 << 1, // property can be only read, not written

                   DontEnum     = 1 << 2, // property doesn't appear in (for .. in ..)

                   DontDelete   = 1 << 3, // property can't be deleted

                   Internal     = 1 << 4, // an internal property, set to bypass checks

                   Function     = 1 << 5, // property is a function - only used by static hashtables

                   GetterSetter = 1 << 6 }; // property is a getter or setter

  /**

   * Class Information

   */

  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.

     */

    const HashTable *propHashTable;

    /**

     * Reserved for future extension.

     */

    void *dummy;

  };

  // This is an internal value object which stores getter and setter functions

  // for a property.

  class GetterSetterImp : public JSCell {

  public:

    JSType type() const { return GetterSetterType; }

    GetterSetterImp() : getter(0), setter(0) { }

    virtual JSValue *toPrimitive(ExecState *exec, JSType preferred = UnspecifiedType) const;

    virtual bool toBoolean(ExecState *exec) const;

    virtual double toNumber(ExecState *exec) const;

    virtual UString toString(ExecState *exec) const;

    virtual JSObject *toObject(ExecState *exec) const;

    IMPORT virtual void mark();

    JSObject *getGetter() { return getter; }

    void setGetter(JSObject *g) { getter = g; }

    JSObject *getSetter() { return setter; }

    void setSetter(JSObject *s) { setter = s; }

  private:

    JSObject *getter;

    JSObject *setter;  

  };

  class JSObject : public JSCell {

  public:

    /**

     * Creates a new JSObject with the specified prototype

     *

     * @param proto The prototype

     */

    JSObject(JSValue* proto);

    /**

     * Creates a new JSObject with a prototype of jsNull()

     * (that is, the ECMAScript "null" value, not a null object pointer).

     */

    JSObject();

    IMPORT virtual void mark();

    IMPORT virtual JSType type() const;

    /**

     * A pointer to a ClassInfo struct for this class. This provides a basic

     * facility for run-time type information, and can be used to check an

     * object's class an inheritance (see inherits()). This should

     * always return a statically declared pointer, or 0 to indicate that

     * there is no class information.

     *

     * This is primarily useful if you have application-defined classes that you

     * wish to check against for casting purposes.

     *

     * For example, to specify the class info for classes FooImp and BarImp,

     * where FooImp inherits from BarImp, you would add the following in your

     * class declarations:

     *

     * \code

     *   class BarImp : public JSObject {

     *     virtual const ClassInfo *classInfo() const { return &info; }

     *     static const ClassInfo info;

     *     // ...

     *   };

     *

     *   class FooImp : public JSObject {

     *     virtual const ClassInfo *classInfo() const { return &info; }

     *     static const ClassInfo info;

     *     // ...

     *   };

     * \endcode

     *

     * And in your source file:

     *

     * \code

     *   const ClassInfo BarImp::info = {"Bar", 0, 0, 0}; // no parent class

     *   const ClassInfo FooImp::info = {"Foo", &BarImp::info, 0, 0};

     * \endcode

     *

     * @see inherits()

     */

    IMPORT virtual const ClassInfo *classInfo() const;

    /**

     * Checks whether this object inherits from the class with the specified

     * classInfo() pointer. This requires that both this class and the other

     * class return a non-NULL pointer for their classInfo() methods (otherwise

     * it will return false).

     *

     * For example, for two JSObject pointers obj1 and obj2, you can check

     * if obj1's class inherits from obj2's class using the following:

     *

     *   if (obj1->inherits(obj2->classInfo())) {

     *     // ...

     *   }

     *

     * If you have a handle to a statically declared ClassInfo, such as in the

     * classInfo() example, you can check for inheritance without needing

     * an instance of the other class:

     *

     *   if (obj1->inherits(FooImp::info)) {

     *     // ...

     *   }

     *

     * @param cinfo The ClassInfo pointer for the class you want to check

     * inheritance against.

     * @return true if this object's class inherits from class with the

     * ClassInfo pointer specified in cinfo

     */

    bool inherits(const ClassInfo *cinfo) const;

    // internal properties (ECMA 262-3 8.6.2)

    /**

     * Returns the prototype of this object. Note that this is not the same as

     * the "prototype" property.

     *

     * See ECMA 8.6.2

     *

     * @return The object's prototype

     */

    JSValue *prototype() const;

    void setPrototype(JSValue *proto);

    /**

     * Returns the class name of the object

     *

     * See ECMA 8.6.2

     *

     * @return The object's class name

     */

    /**

     * Implementation of the [[Class]] internal property (implemented by all

     * Objects)

     *

     * The default implementation uses classInfo().

     * You should either implement classInfo(), or

     * if you simply need a classname, you can reimplement className()

     * instead.

     */

    IMPORT virtual UString className() const;

    /**

     * Retrieves the specified property from the object. If neither the object

     * or any other object in it's prototype chain have the property, this

     * function will return Undefined.

     *

     * See ECMA 8.6.2.1

     *

     * @param exec The current execution state

     * @param propertyName The name of the property to retrieve

     *

     * @return The specified property, or Undefined

     */

    IMPORT JSValue *get(ExecState *exec, const Identifier &propertyName) const;

    IMPORT JSValue *get(ExecState *exec, unsigned propertyName) const;

    bool getPropertySlot(ExecState *, const Identifier&, PropertySlot&);

    bool getPropertySlot(ExecState *, unsigned, PropertySlot&);

    virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);

    IMPORT virtual bool getOwnPropertySlot(ExecState *, unsigned index, PropertySlot&);

    /**

     * Sets the specified property.

     *

     * See ECMA 8.6.2.2

     *

     * @param exec The current execution state

     * @param propertyName The name of the property to set

     * @param propertyValue The value to set

     */

    IMPORT virtual void put(ExecState* exec, const Identifier &propertyName, JSValue* value, int attr = None);

    IMPORT virtual void put(ExecState* exec, unsigned propertyName, JSValue* value, int attr = None);

    /**

     * Used to check whether or not a particular property is allowed to be set

     * on an object

     *

     * See ECMA 8.6.2.3

     *

     * @param exec The current execution state

     * @param propertyName The name of the property

     * @return true if the property can be set, otherwise false

     */

    /**

     * Implementation of the [[CanPut]] internal property (implemented by all

     * Objects)

     */

    IMPORT virtual bool canPut(ExecState *exec, const Identifier &propertyName) const;

    /**

     * Checks if a property is enumerable, that is if it doesn't have the DontEnum

     * flag set

     *

     * See ECMA 15.2.4

     * @param exec The current execution state

     * @param propertyName The name of the property

     * @return true if the property is enumerable, otherwise false

     */

    bool propertyIsEnumerable(ExecState *exec, const Identifier &propertyName) const;

    /**

     * Checks to see whether the object (or any object in it's prototype chain)

     * has a property with the specified name.

     *

     * See ECMA 8.6.2.4

     *

     * @param exec The current execution state

     * @param propertyName The name of the property to check for

     * @return true if the object has the property, otherwise false

     */

    IMPORT bool hasProperty(ExecState *exec, const Identifier &propertyName) const;

    bool hasProperty(ExecState *exec, unsigned propertyName) const;

    /**

     * Removes the specified property from the object.

     *

     * See ECMA 8.6.2.5

     *

     * @param exec The current execution state

     * @param propertyName The name of the property to delete

     * @return true if the property was successfully deleted or did not

     * exist on the object. false if deleting the specified property is not

     * allowed.

     */

    IMPORT virtual bool deleteProperty(ExecState *exec, const Identifier &propertyName);

    IMPORT virtual bool deleteProperty(ExecState *exec, unsigned propertyName);

    /**

     * Converts the object into a primitive value. The value return may differ

     * depending on the supplied hint

     *

     * See ECMA 8.6.2.6

     *

     * @param exec The current execution state

     * @param hint The desired primitive type to convert to

     * @return A primitive value converted from the objetc. Note that the

     * type of primitive value returned may not be the same as the requested

     * hint.

     */

    /**

     * Implementation of the [[DefaultValue]] internal property (implemented by

     * all Objects)

     */

    IMPORT virtual JSValue *defaultValue(ExecState *exec, JSType hint) const;

    /**

     * Whether or not the object implements the construct() method. If this

     * returns false you should not call the construct() method on this

     * object (typically, an assertion will fail to indicate this).

     *

     * @return true if this object implements the construct() method, otherwise

     * false

     */

    IMPORT virtual bool implementsConstruct() const;

    /**

     * Creates a new object based on this object. Typically this means the

     * following:

     * 1. A new object is created

     * 2. The prototype of the new object is set to the value of this object's

     *    "prototype" property

     * 3. The call() method of this object is called, with the new object

     *    passed as the this value

     * 4. The new object is returned

     *

     * In some cases, Host objects may differ from these semantics, although

     * this is discouraged.

     *

     * If an error occurs during construction, the execution state's exception

     * will be set. This can be tested for with ExecState::hadException().

     * Under some circumstances, the exception object may also be returned.

     *

     * Note: This function should not be called if implementsConstruct() returns

     * false, in which case it will result in an assertion failure.

     *

     * @param exec The current execution state

     * @param args The arguments to be passed to call() once the new object has

     * been created

     * @return The newly created & initialized object

     */

    /**

     * Implementation of the [[Construct]] internal property

     */

    IMPORT virtual JSObject* construct(ExecState* exec, const List& args);

    IMPORT virtual JSObject* construct(ExecState* exec, const List& args, const Identifier& functionName, const UString& sourceURL, int lineNumber);

    /**

     * Whether or not the object implements the call() method. If this returns

     * false you should not call the call() method on this object (typically,

     * an assertion will fail to indicate this).

     *

     * @return true if this object implements the call() method, otherwise

     * false

     */

    IMPORT virtual bool implementsCall() const;

    /**

     * Calls this object as if it is a function.

     *

     * Note: This function should not be called if implementsCall() returns

     * false, in which case it will result in an assertion failure.

     *

     * See ECMA 8.6.2.3

     *

     * @param exec The current execution state

     * @param thisObj The obj to be used as "this" within function execution.

     * Note that in most cases this will be different from the C++ "this"

     * object. For example, if the ECMAScript code "window.location->toString()"

     * is executed, call() will be invoked on the C++ object which implements

     * the toString method, with the thisObj being window.location

     * @param args List of arguments to be passed to the function

     * @return The return value from the function

     */

    IMPORT JSValue *call(ExecState *exec, JSObject *thisObj, const List &args);

    IMPORT virtual JSValue *callAsFunction(ExecState *exec, JSObject *thisObj, const List &args);

    /**

     * Whether or not the object implements the hasInstance() method. If this

     * returns false you should not call the hasInstance() method on this

     * object (typically, an assertion will fail to indicate this).

     *

     * @return true if this object implements the hasInstance() method,

     * otherwise false

     */

    IMPORT virtual bool implementsHasInstance() const;

    /**

     * Checks whether value delegates behavior to this object. Used by the

     * instanceof operator.

     *

     * @param exec The current execution state

     * @param value The value to check

     * @return true if value delegates behavior to this object, otherwise

     * false

     */

    IMPORT virtual bool hasInstance(ExecState *exec, JSValue *value);

    IMPORT virtual void getPropertyNames(ExecState*, PropertyNameArray&);

    virtual JSValue *toPrimitive(ExecState *exec, JSType preferredType = UnspecifiedType) const;

    IMPORT virtual bool toBoolean(ExecState *exec) const;

    IMPORT virtual double toNumber(ExecState *exec) const;

    IMPORT virtual UString toString(ExecState *exec) const;

    IMPORT virtual JSObject *toObject(ExecState *exec) const;

    bool getPropertyAttributes(const Identifier& propertyName, unsigned& attributes) const;

    // WebCore uses this to make document.all and style.filter undetectable

    virtual bool masqueradeAsUndefined() const { return false; }

    // This get function only looks at the property map.

    // This is used e.g. by lookupOrCreateFunction (to cache a function, we don't want

    // to look up in the prototype, it might already exist there)

    JSValue *getDirect(const Identifier& propertyName) const

        { return _prop.get(propertyName); }

    JSValue **getDirectLocation(const Identifier& propertyName)

        { return _prop.getLocation(propertyName); }

    IMPORT void putDirect(const Identifier &propertyName, JSValue *value, int attr = 0);

    IMPORT void putDirect(const Identifier &propertyName, int value, int attr = 0);

    IMPORT void removeDirect(const Identifier &propertyName);

    // convenience to add a function property under the function's own built-in name

    void putDirectFunction(InternalFunctionImp*, int attr = 0);

    IMPORT void fillGetterPropertySlot(PropertySlot& slot, JSValue **location);

    void defineGetter(ExecState *exec, const Identifier& propertyName, JSObject *getterFunc);

    void defineSetter(ExecState *exec, const Identifier& propertyName, JSObject *setterFunc);

    bool checkStackDepthTooDeep();

    /**

     * Remove all properties from this object.

     * This doesn't take DontDelete into account, and isn't in the ECMA spec.

     * It's simply a quick way to remove everything stored in the property map.

     */

    void clearProperties() { _prop.clear(); }

    void saveProperties(SavedProperties &p) const { _prop.save(p); }

    void restoreProperties(const SavedProperties &p) { _prop.restore(p); }

    virtual bool isActivation() { return false; }

  protected:

    PropertyMap _prop;

  private:

    const HashEntry* findPropertyHashEntry( const Identifier& propertyName ) const;

    JSValue *_proto;

  };

  /**

   * Types of Native Errors available. For custom errors, GeneralError

   * should be used.

   */

  enum ErrorType { GeneralError   = 0,

                   EvalError      = 1,

                   RangeError     = 2,

                   ReferenceError = 3,

                   SyntaxError    = 4,

                   TypeError      = 5,

                   URIError       = 6};

  /**

   * @short Factory methods for error objects.

   */

  class Error {

  public:

    /**

     * Factory method for error objects.

     *

     * @param exec The current execution state

     * @param errtype Type of error.

     * @param message Optional error message.

     * @param lineNumber Optional line number.

     * @param sourceId Optional source id.

     * @param sourceURL Optional source URL.

     */

    static JSObject *create(ExecState *, ErrorType, const UString &message, int lineNumber, int sourceId, const UString &sourceURL);

    static JSObject *create(ExecState *, ErrorType, const char *message);

    /**

     * Array of error names corresponding to ErrorType

     */

    static const char * const * const errorNames;

  };

JSObject *throwError(ExecState *, ErrorType, const UString &message, int lineNumber, int sourceId, const UString &sourceURL);

IMPORT JSObject *throwError(ExecState *, ErrorType, const UString &message);

IMPORT JSObject *throwError(ExecState *, ErrorType, const char *message);

IMPORT JSObject *throwError(ExecState *, ErrorType);

inline JSObject::JSObject(JSValue* proto)

    : _proto(proto)

{

    assert(proto);

}

inline JSObject::JSObject()

    : _proto(jsNull())

{

}

inline JSValue *JSObject::prototype() const

{

    return _proto;

}