object.h

/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 1999-2001 Harri Porten ([email protected])
 *  Copyright (C) 2001 Peter Kelly ([email protected])
 *  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 "global.h"
#include "JSType.h"
#include "interpreter.h"
#include "property_map.h"
#include "property_slot.h"
#include "scope_chain.h"
#include <wtf/AlwaysInline.h>
#include "propertydescriptor.h"

namespace KJS
{

struct HashTable;
struct HashEntry;
struct ListImp;
class InternalFunctionImp;
class PropertyNameArray;

struct ClassInfo {
    const char *className;
    const ClassInfo *parentClass;
    const HashTable *propHashTable;
    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(nullptr), setter(nullptr) { }

    virtual JSValue *toPrimitive(ExecState *exec, JSType preferred = UnspecifiedType) const;
    virtual bool getPrimitiveNumber(ExecState *, double &number, JSValue *&value);
    virtual bool toBoolean(ExecState *exec) const;
    virtual double toNumber(ExecState *exec) const;
    virtual UString toString(ExecState *exec) const;
    virtual JSObject *toObject(ExecState *exec) const;

    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 KJS_EXPORT JSObject : public JSCell
{
public:
    explicit JSObject(JSValue *proto);

    explicit JSObject();

    virtual void mark();
    virtual JSType type() const;

    virtual const ClassInfo *classInfo() const;

    bool inherits(const ClassInfo *cinfo) const;

    // internal properties (ECMA 262-3 8.6.2)

    JSValue *prototype() const;
    void setPrototype(JSValue *proto);

    virtual UString className() const;

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

    bool getPropertySlot(ExecState *, const Identifier &, PropertySlot &);
    bool getPropertySlot(ExecState *, unsigned, PropertySlot &);
    // Fills the PropertyDescriptor looking the ownPropertys and all prototypes until found.
    bool getPropertyDescriptor(ExecState *, const Identifier &propertyName, PropertyDescriptor &);

    virtual bool getOwnPropertySlot(ExecState *, const Identifier &, PropertySlot &);
    virtual bool getOwnPropertySlot(ExecState *, unsigned index, PropertySlot &);
    virtual bool getOwnPropertyDescriptor(ExecState *, const Identifier &, PropertyDescriptor &);

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

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

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

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

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

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

    virtual bool implementsConstruct() const;

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

    virtual JSObject *valueClone(Interpreter *targetCtx) const;

    virtual bool isFunctionType() const;

    JSValue *call(ExecState *exec, JSObject *thisObj, const List &args); // ### TODO: consolidate with below
    virtual JSValue *callAsFunction(ExecState *exec, JSObject *thisObj, const List &args);

    virtual bool implementsHasInstance() const;

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

    void getPropertyNames(ExecState *, PropertyNameArray &, PropertyMap::PropertyMode mode = PropertyMap::ExcludeDontEnumProperties);
    virtual void getOwnPropertyNames(ExecState *, PropertyNameArray &, PropertyMap::PropertyMode mode);

    virtual JSValue *toPrimitive(ExecState *exec, JSType preferredType = UnspecifiedType) const;
    virtual bool getPrimitiveNumber(ExecState *, double &number, JSValue *&value);
    virtual bool toBoolean(ExecState *exec) const;
    virtual double toNumber(ExecState *exec) const;
    virtual UString toString(ExecState *exec) const;
    virtual JSObject *toObject(ExecState *exec) const;

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

    // Returns whether the object should be treated as undefined when doing equality comparisons
    virtual bool masqueradeAsUndefined() const
    {
        return false;
    }

    // This get function only looks at the property map for Object.
    // It is virtual because for all custom-data classes we want to by-pass
    // the prototype and get it directly. For example called from
    // Object::defineOwnProperty to directly get GetterSetterImp and update it.
    // 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)
    virtual JSValue *getDirect(const Identifier &propertyName) const
    {
        return _prop.get(propertyName);
    }
    JSValue **getDirectLocation(const Identifier &propertyName)
    {
        return _prop.getLocation(propertyName);
    }

    // If this method returns non-0, there is already a property
    // with name propertyName that's not readonly and not a setter-getter
    // which can be updated via the returned pointer.
    JSValue **getDirectWriteLocation(const Identifier &propertyName)
    {
        return _prop.getWriteLocation(propertyName);
    }

    // This function is virtual to directly store, by-pass the prototype, values
    // for all custom-data classes like the Array. For example an Array with a prototype
    // to store values via getter/setter. It would be impossible to store a value
    // by-passing the getter/setter prototype.
    // This is for example called in Object::defineOwnProperty to directly store the values.
    // Same for removeDirect.
    virtual void putDirect(const Identifier &propertyName, JSValue *value, int attr = 0)
    {
        _prop.put(propertyName, value, attr);
    }
    virtual void putDirect(const Identifier &propertyName, int value, int attr = 0);
    virtual 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);

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

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

    virtual bool defineOwnProperty(ExecState *exec, const Identifier &propertyName, PropertyDescriptor &desc, bool shouldThrow);

    void preventExtensions();
    bool isExtensible()
    {
        return _prop.isExtensible();
    }

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

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

    virtual bool isActivation()   const
    {
        return false;
    }
    virtual bool isGlobalObject() const
    {
        return false;
    }

    // This is used to keep track of whether scope object have local
    // variables introduced by something other than 'var'
    bool isLocalInjected()  const
    {
        return _prop.m_objLocalInjected;
    }
    void setLocalInjected()
    {
        _prop.m_objLocalInjected = true;
    }

protected:
    PropertyMap _prop;
private:

    const HashEntry *findPropertyHashEntry(const Identifier &propertyName) const;
    JSValue *_proto;
#ifdef _WIN32
    JSObject(const JSObject &);
    JSObject &operator=(const JSObject &);
#endif
};

enum ErrorType { GeneralError   = 0,
                 EvalError      = 1,
                 RangeError     = 2,
                 ReferenceError = 3,
                 SyntaxError    = 4,
                 TypeError      = 5,
                 URIError       = 6
               };

class KJS_EXPORT Error
{
public:
    static JSObject *create(ExecState *, ErrorType, const UString &message, int lineNumber, int sourceId, const UString &sourceURL);
    static JSObject *create(ExecState *, ErrorType, const char *message);

    static const char *const *const errorNames;
};

KJS_EXPORT JSObject *throwError(ExecState *, ErrorType, const UString &message, int lineNumber, int sourceId, const UString &sourceURL);
KJS_EXPORT JSObject *throwError(ExecState *, ErrorType, const UString &message);
KJS_EXPORT JSObject *throwError(ExecState *, ErrorType, const char *message);
KJS_EXPORT 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;
}

inline void JSObject::setPrototype(JSValue *proto)
{
    assert(proto);
    _proto = proto;
}

inline bool JSObject::inherits(const ClassInfo *info) const
{
    for (const ClassInfo *ci = classInfo(); ci; ci = ci->parentClass)
        if (ci == info) {
            return true;
        }
    return false;
}

inline void JSObject::fillDirectLocationSlot(PropertySlot &slot,
        JSValue **location)
{
    if (_prop.hasGetterSetterProperties() &&
            (*location)->type() == GetterSetterType) {
        fillGetterPropertySlot(slot, location);
    } else {
        slot.setValueSlot(this, location);
    }
}

// this method is here to be after the inline declaration of JSObject::inherits
inline bool JSCell::isObject(const ClassInfo *info) const
{
    return isObject() && static_cast<const JSObject *>(this)->inherits(info);
}

// this method is here to be after the inline declaration of JSCell::isObject
inline bool JSValue::isObject(const ClassInfo *c) const
{
    return !JSImmediate::isImmediate(this) && asCell()->isObject(c);
}

// It may seem crazy to inline a function this large but it makes a big difference
// since this is function very hot in variable lookup
inline bool JSObject::getPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
{
    JSObject *object = this;
    while (true) {
        if (object->getOwnPropertySlot(exec, propertyName, slot)) {
            return true;
        }

        JSValue *proto = object->_proto;
        if (!proto->isObject()) {
            return false;
        }

        object = static_cast<JSObject *>(proto);
    }
}

inline void JSObject::getPropertyNames(ExecState *exec, PropertyNameArray &propertyNames, PropertyMap::PropertyMode mode)
{
    for (JSObject *cur = this; cur; cur = cur->_proto->getObject()) {
        cur->getOwnPropertyNames(exec, propertyNames, mode);
    }
}

inline JSValue *JSObject::toPrimitive(ExecState *exec, JSType preferredType) const
{
    return defaultValue(exec, preferredType);
}

inline JSValue *JSObject::call(ExecState *exec, JSObject *thisObj, const List &args)
{
    return callAsFunction(exec, thisObj, args);
}

} // namespace

#endif // KJS_OBJECT_H