/*

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

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

 *  Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.

 *  Copyright (C) 2007 Eric Seidel (eric@webkit.org)

 *

 *  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.

 *

 */

#include "config.h"

#include "JSObject.h"

#include "DatePrototype.h"

#include "ErrorConstructor.h"

#include "GetterSetter.h"

#include "JSFunction.h"

#include "JSGlobalObject.h"

#include "NativeErrorConstructor.h"

#include "ObjectPrototype.h"

#include "PropertyDescriptor.h"

#include "PropertyNameArray.h"

#include "Lookup.h"

#include "Nodes.h"

#include "Operations.h"

#include <math.h>

#include <wtf/Assertions.h>

namespace JSC {

ASSERT_CLASS_FITS_IN_CELL(JSObject);

static inline void getClassPropertyNames(ExecState* exec, const ClassInfo* classInfo, PropertyNameArray& propertyNames, EnumerationMode mode)

{

    // Add properties from the static hashtables of properties

    for (; classInfo; classInfo = classInfo->parentClass) {

        const HashTable* table = classInfo->propHashTable(exec);

        if (!table)

            continue;

        table->initializeIfNeeded(exec);

        ASSERT(table->table);

        int hashSizeMask = table->compactSize - 1;

        const HashEntry* entry = table->table;

        for (int i = 0; i <= hashSizeMask; ++i, ++entry) {

            if (entry->key() && (!(entry->attributes() & DontEnum) || (mode == IncludeDontEnumProperties)))

                propertyNames.add(entry->key());

        }

    }

}

void JSObject::markChildren(MarkStack& markStack)

{

#ifndef NDEBUG

    bool wasCheckingForDefaultMarkViolation = markStack.m_isCheckingForDefaultMarkViolation;

    markStack.m_isCheckingForDefaultMarkViolation = false;

#endif

    markChildrenDirect(markStack);

#ifndef NDEBUG

    markStack.m_isCheckingForDefaultMarkViolation = wasCheckingForDefaultMarkViolation;

#endif

}

UString JSObject::className() const

{

    const ClassInfo* info = classInfo();

    if (info)

        return info->className;

    return "Object";

}

bool JSObject::getOwnPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot)

{

    return getOwnPropertySlot(exec, Identifier::from(exec, propertyName), slot);

}

static void throwSetterError(ExecState* exec)

{

    throwError(exec, createTypeError(exec, "setting a property that has only a getter"));

}

// ECMA 8.6.2.2

void JSObject::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)

{

    ASSERT(value);

    ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));

    if (propertyName == exec->propertyNames().underscoreProto) {

        // Setting __proto__ to a non-object, non-null value is silently ignored to match Mozilla.

        if (!value.isObject() && !value.isNull())

            return;

        if (!setPrototypeWithCycleCheck(value))

            throwError(exec, createError(exec, "cyclic __proto__ value"));

        return;

    }

    // Check if there are any setters or getters in the prototype chain

    JSValue prototype;

    for (JSObject* obj = this; !obj->structure()->hasGetterSetterProperties(); obj = asObject(prototype)) {

        prototype = obj->prototype();

        if (prototype.isNull()) {

            putDirectInternal(exec->globalData(), propertyName, value, 0, true, slot);

            return;

        }

    }

    unsigned attributes;

    JSCell* specificValue;

    if ((m_structure->get(propertyName, attributes, specificValue) != WTF::notFound) && attributes & ReadOnly)

        return;

    for (JSObject* obj = this; ; obj = asObject(prototype)) {

        if (JSValue gs = obj->getDirect(propertyName)) {

            if (gs.isGetterSetter()) {

                JSObject* setterFunc = asGetterSetter(gs)->setter();        

                if (!setterFunc) {

                    throwSetterError(exec);

                    return;

                }

                CallData callData;

                CallType callType = setterFunc->getCallData(callData);

                MarkedArgumentBuffer args;

                args.append(value);

                call(exec, setterFunc, callType, callData, this, args);

                return;

            }

            // If there's an existing property on the object or one of its 

            // prototypes it should be replaced, so break here.

            break;

        }

        prototype = obj->prototype();

        if (prototype.isNull())

            break;

    }

    putDirectInternal(exec->globalData(), propertyName, value, 0, true, slot);

    return;

}

void JSObject::put(ExecState* exec, unsigned propertyName, JSValue value)

{

    PutPropertySlot slot;

    put(exec, Identifier::from(exec, propertyName), value, slot);

}

void JSObject::putWithAttributes(JSGlobalData* globalData, const Identifier& propertyName, JSValue value, unsigned attributes, bool checkReadOnly, PutPropertySlot& slot)

{

    putDirectInternal(*globalData, propertyName, value, attributes, checkReadOnly, slot);

}

void JSObject::putWithAttributes(JSGlobalData* globalData, const Identifier& propertyName, JSValue value, unsigned attributes)

{

    putDirectInternal(*globalData, propertyName, value, attributes);

}

void JSObject::putWithAttributes(JSGlobalData* globalData, unsigned propertyName, JSValue value, unsigned attributes)

{

    putWithAttributes(globalData, Identifier::from(globalData, propertyName), value, attributes);

}

void JSObject::putWithAttributes(ExecState* exec, const Identifier& propertyName, JSValue value, unsigned attributes, bool checkReadOnly, PutPropertySlot& slot)

{

    putDirectInternal(exec->globalData(), propertyName, value, attributes, checkReadOnly, slot);

}

void JSObject::putWithAttributes(ExecState* exec, const Identifier& propertyName, JSValue value, unsigned attributes)

{

    putDirectInternal(exec->globalData(), propertyName, value, attributes);

}

void JSObject::putWithAttributes(ExecState* exec, unsigned propertyName, JSValue value, unsigned attributes)

{

    putWithAttributes(exec, Identifier::from(exec, propertyName), value, attributes);

}

bool JSObject::hasProperty(ExecState* exec, const Identifier& propertyName) const

{

    PropertySlot slot;

    return const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot);

}

bool JSObject::hasProperty(ExecState* exec, unsigned propertyName) const

{

    PropertySlot slot;

    return const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot);

}

// ECMA 8.6.2.5

bool JSObject::deleteProperty(ExecState* exec, const Identifier& propertyName)

{

    unsigned attributes;

    JSCell* specificValue;

    if (m_structure->get(propertyName, attributes, specificValue) != WTF::notFound) {

        if ((attributes & DontDelete))

            return false;

        removeDirect(propertyName);

        return true;

    }

    // Look in the static hashtable of properties

    const HashEntry* entry = findPropertyHashEntry(exec, propertyName);

    if (entry && entry->attributes() & DontDelete)

        return false; // this builtin property can't be deleted

    // FIXME: Should the code here actually do some deletion?

    return true;

}

bool JSObject::hasOwnProperty(ExecState* exec, const Identifier& propertyName) const

{

    PropertySlot slot;

    return const_cast<JSObject*>(this)->getOwnPropertySlot(exec, propertyName, slot);

}

bool JSObject::deleteProperty(ExecState* exec, unsigned propertyName)

{

    return deleteProperty(exec, Identifier::from(exec, propertyName));

}

static ALWAYS_INLINE JSValue callDefaultValueFunction(ExecState* exec, const JSObject* object, const Identifier& propertyName)

{

    JSValue function = object->get(exec, propertyName);

    CallData callData;

    CallType callType = getCallData(function, callData);

    if (callType == CallTypeNone)

        return exec->exception();

    // Prevent "toString" and "valueOf" from observing execution if an exception

    // is pending.

    if (exec->hadException())

        return exec->exception();

    JSValue result = call(exec, function, callType, callData, const_cast<JSObject*>(object), exec->emptyList());

    ASSERT(!result.isGetterSetter());

    if (exec->hadException())

        return exec->exception();

    if (result.isObject())

        return JSValue();

    return result;

}

bool JSObject::getPrimitiveNumber(ExecState* exec, double& number, JSValue& result)

{

    result = defaultValue(exec, PreferNumber);

    number = result.toNumber(exec);

    return !result.isString();

}

// ECMA 8.6.2.6

JSValue JSObject::defaultValue(ExecState* exec, PreferredPrimitiveType hint) const

{

    // Must call toString first for Date objects.

    if ((hint == PreferString) || (hint != PreferNumber && prototype() == exec->lexicalGlobalObject()->datePrototype())) {

        JSValue value = callDefaultValueFunction(exec, this, exec->propertyNames().toString);

        if (value)

            return value;

        value = callDefaultValueFunction(exec, this, exec->propertyNames().valueOf);

        if (value)

            return value;

    } else {

        JSValue value = callDefaultValueFunction(exec, this, exec->propertyNames().valueOf);

        if (value)

            return value;

        value = callDefaultValueFunction(exec, this, exec->propertyNames().toString);

        if (value)

            return value;

    }

    ASSERT(!exec->hadException());

    return throwError(exec, createTypeError(exec, "No default value"));

}

const HashEntry* JSObject::findPropertyHashEntry(ExecState* exec, const Identifier& propertyName) const

{

    for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {

        if (const HashTable* propHashTable = info->propHashTable(exec)) {

            if (const HashEntry* entry = propHashTable->entry(exec, propertyName))

                return entry;

        }

    }

    return 0;

}

void JSObject::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes)

{

    JSValue object = getDirect(propertyName);

    if (object && object.isGetterSetter()) {

        ASSERT(m_structure->hasGetterSetterProperties());

        asGetterSetter(object)->setGetter(getterFunction);

        return;

    }

    PutPropertySlot slot;

    GetterSetter* getterSetter = new (exec) GetterSetter(exec);

    putDirectInternal(exec->globalData(), propertyName, getterSetter, attributes | Getter, true, slot);

    // putDirect will change our Structure if we add a new property. For

    // getters and setters, though, we also need to change our Structure

    // if we override an existing non-getter or non-setter.

    if (slot.type() != PutPropertySlot::NewProperty) {

        if (!m_structure->isDictionary()) {

            RefPtr<Structure> structure = Structure::getterSetterTransition(m_structure);

            setStructure(structure.release());

        }

    }

    m_structure->setHasGetterSetterProperties(true);

    getterSetter->setGetter(getterFunction);

}

void JSObject::defineSetter(ExecState* exec, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes)

{

    JSValue object = getDirect(propertyName);

    if (object && object.isGetterSetter()) {

        ASSERT(m_structure->hasGetterSetterProperties());

        asGetterSetter(object)->setSetter(setterFunction);

        return;

    }

    PutPropertySlot slot;

    GetterSetter* getterSetter = new (exec) GetterSetter(exec);

    putDirectInternal(exec->globalData(), propertyName, getterSetter, attributes | Setter, true, slot);

    // putDirect will change our Structure if we add a new property. For

    // getters and setters, though, we also need to change our Structure

    // if we override an existing non-getter or non-setter.

    if (slot.type() != PutPropertySlot::NewProperty) {

        if (!m_structure->isDictionary()) {

            RefPtr<Structure> structure = Structure::getterSetterTransition(m_structure);

            setStructure(structure.release());

        }

    }

    m_structure->setHasGetterSetterProperties(true);

    getterSetter->setSetter(setterFunction);

}

JSValue JSObject::lookupGetter(ExecState*, const Identifier& propertyName)

{

    JSObject* object = this;

    while (true) {

        if (JSValue value = object->getDirect(propertyName)) {

            if (!value.isGetterSetter())

                return jsUndefined();

            JSObject* functionObject = asGetterSetter(value)->getter();

            if (!functionObject)

                return jsUndefined();

            return functionObject;

        }

        if (!object->prototype() || !object->prototype().isObject())

            return jsUndefined();

        object = asObject(object->prototype());

    }

}

JSValue JSObject::lookupSetter(ExecState*, const Identifier& propertyName)

{

    JSObject* object = this;

    while (true) {

        if (JSValue value = object->getDirect(propertyName)) {

            if (!value.isGetterSetter())

                return jsUndefined();

            JSObject* functionObject = asGetterSetter(value)->setter();

            if (!functionObject)

                return jsUndefined();

            return functionObject;

        }

        if (!object->prototype() || !object->prototype().isObject())

            return jsUndefined();

        object = asObject(object->prototype());

    }

}

bool JSObject::hasInstance(ExecState* exec, JSValue value, JSValue proto)

{

    if (!value.isObject())

        return false;

    if (!proto.isObject()) {

        throwError(exec, createTypeError(exec, "instanceof called on an object with an invalid prototype property."));

        return false;

    }

    JSObject* object = asObject(value);

    while ((object = object->prototype().getObject())) {

        if (proto == object)

            return true;

    }

    return false;

}

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

{

    PropertyDescriptor descriptor;

    if (!const_cast<JSObject*>(this)->getOwnPropertyDescriptor(exec, propertyName, descriptor))

        return false;

    return descriptor.enumerable();

}

bool JSObject::getPropertySpecificValue(ExecState*, const Identifier& propertyName, JSCell*& specificValue) const

{

    unsigned attributes;

    if (m_structure->get(propertyName, attributes, specificValue) != WTF::notFound)

        return true;

    // This could be a function within the static table? - should probably

    // also look in the hash?  This currently should not be a problem, since

    // we've currently always call 'get' first, which should have populated

    // the normal storage.

    return false;

}

void JSObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)

{

    getOwnPropertyNames(exec, propertyNames, mode);

    if (prototype().isNull())

        return;

    JSObject* prototype = asObject(this->prototype());

    while(1) {

        if (prototype->structure()->typeInfo().overridesGetPropertyNames()) {

            prototype->getPropertyNames(exec, propertyNames, mode);

            break;

        }

        prototype->getOwnPropertyNames(exec, propertyNames, mode);

        JSValue nextProto = prototype->prototype();

        if (nextProto.isNull())

            break;

        prototype = asObject(nextProto);

    }

}

void JSObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)

{

    m_structure->getPropertyNames(propertyNames, mode);

    getClassPropertyNames(exec, classInfo(), propertyNames, mode);

}

bool JSObject::toBoolean(ExecState*) const

{

    return true;

}

double JSObject::toNumber(ExecState* exec) const

{

    JSValue primitive = toPrimitive(exec, PreferNumber);

    if (exec->hadException()) // should be picked up soon in Nodes.cpp

        return 0.0;

    return primitive.toNumber(exec);

}

UString JSObject::toString(ExecState* exec) const

{

    JSValue primitive = toPrimitive(exec, PreferString);

    if (exec->hadException())

        return "";

    return primitive.toString(exec);

}

JSObject* JSObject::toObject(ExecState*) const

{

    return const_cast<JSObject*>(this);

}

JSObject* JSObject::toThisObject(ExecState*) const

{

    return const_cast<JSObject*>(this);

}

JSObject* JSObject::unwrappedObject()

{

    return this;

}

void JSObject::removeDirect(const Identifier& propertyName)

{

    size_t offset;

    if (m_structure->isUncacheableDictionary()) {

        offset = m_structure->removePropertyWithoutTransition(propertyName);

        if (offset != WTF::notFound)

            putDirectOffset(offset, jsUndefined());

        return;

    }

    RefPtr<Structure> structure = Structure::removePropertyTransition(m_structure, propertyName, offset);

    setStructure(structure.release());

    if (offset != WTF::notFound)

        putDirectOffset(offset, jsUndefined());

}

void JSObject::putDirectFunction(ExecState* exec, InternalFunction* function, unsigned attr)

{

    putDirectFunction(Identifier(exec, function->name(exec)), function, attr);

}

void JSObject::putDirectFunction(ExecState* exec, JSFunction* function, unsigned attr)

{

    putDirectFunction(Identifier(exec, function->name(exec)), function, attr);

}

void JSObject::putDirectFunctionWithoutTransition(ExecState* exec, InternalFunction* function, unsigned attr)

{

    putDirectFunctionWithoutTransition(Identifier(exec, function->name(exec)), function, attr);

}

void JSObject::putDirectFunctionWithoutTransition(ExecState* exec, JSFunction* function, unsigned attr)