/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtScript module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "config.h"

#include "qscriptvalue.h"

#include "qscriptvalue_p.h"

#include "qscriptengine.h"

#include "qscriptengine_p.h"

#include "qscriptstring_p.h"

#include "JSArray.h"

#include "JSGlobalObject.h"

#include "JSImmediate.h"

#include "JSObject.h"

#include "JSValue.h"

#include "JSFunction.h"

#include "DateInstance.h"

#include "ErrorInstance.h"

#include "RegExpObject.h"

#include "Identifier.h"

#include "Operations.h"

#include "Arguments.h"

#include <QtCore/qdatetime.h>

#include <QtCore/qregexp.h>

#include <QtCore/qvariant.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qnumeric.h>

#include "utils/qscriptdate_p.h"

#include "bridge/qscriptobject_p.h"

#include "bridge/qscriptclassobject_p.h"

#include "bridge/qscriptvariant_p.h"

#include "bridge/qscriptqobject_p.h"

/*!

  \since 4.3

  \class QScriptValue

  \brief The QScriptValue class acts as a container for the Qt Script data types.

  \ingroup script

  \mainclass

  QScriptValue supports the types defined in the \l{ECMA-262}

  standard: The primitive types, which are Undefined, Null, Boolean,

  Number, and String; and the Object type. Additionally, Qt Script

  has built-in support for QVariant, QObject and QMetaObject.

  For the object-based types (including Date and RegExp), use the

  newT() functions in QScriptEngine (e.g. QScriptEngine::newObject())

  to create a QScriptValue of the desired type. For the primitive types,

  use one of the QScriptValue constructor overloads.

  The methods named isT() (e.g. isBool(), isUndefined()) can be

  used to test if a value is of a certain type. The methods named

  toT() (e.g. toBool(), toString()) can be used to convert a

  QScriptValue to another type. You can also use the generic

  qscriptvalue_cast() function.

  Object values have zero or more properties which are themselves

  QScriptValues. Use setProperty() to set a property of an object, and

  call property() to retrieve the value of a property.

  \snippet doc/src/snippets/code/src_script_qscriptvalue.cpp 0

  Each property can have a set of attributes; these are specified as

  the third (optional) argument to setProperty(). The attributes of a

  property can be queried by calling the propertyFlags() function. The

  following code snippet creates a property that cannot be modified by

  script code:

  \snippet doc/src/snippets/code/src_script_qscriptvalue.cpp 1

  If you want to iterate over the properties of a script object, use

  the QScriptValueIterator class.

  Object values have an internal \c{prototype} property, which can be

  accessed with prototype() and setPrototype(). Properties added to a

  prototype are shared by all objects having that prototype; this is

  referred to as prototype-based inheritance. In practice, it means

  that (by default) the property() function will automatically attempt

  to look up look the property in the prototype() (and in the

  prototype of the prototype(), and so on), if the object itself does

  not have the requested property. Note that this prototype-based

  lookup is not performed by setProperty(); setProperty() will always

  create the property in the script object itself.  For more

  information, see the \l{QtScript} documentation.

  Function objects (objects for which isFunction() returns true) can

  be invoked by calling call(). Constructor functions can be used to

  construct new objects by calling construct().

  Use equals(), strictlyEquals() and lessThan() to compare a QScriptValue

  to another.

  Object values can have custom data associated with them; see the

  setData() and data() functions. By default, this data is not

  accessible to scripts; it can be used to store any data you want to

  associate with the script object. Typically this is used by custom

  class objects (see QScriptClass) to store a C++ type that contains

  the "native" object data.

  Note that a QScriptValue for which isObject() is true only carries a

  reference to an actual object; copying the QScriptValue will only

  copy the object reference, not the object itself. If you want to

  clone an object (i.e. copy an object's properties to another

  object), you can do so with the help of a \c{for-in} statement in

  script code, or QScriptValueIterator in C++.

  \sa QScriptEngine, QScriptValueIterator

*/

/*!

    \enum QScriptValue::SpecialValue

    This enum is used to specify a single-valued type.

    \value UndefinedValue An undefined value.

    \value NullValue A null value.

*/

/*!

    \enum QScriptValue::PropertyFlag

    This enum describes the attributes of a property.

    \value ReadOnly The property is read-only. Attempts by Qt Script code to write to the property will be ignored.

    \value Undeletable Attempts by Qt Script code to \c{delete} the property will be ignored.

    \value SkipInEnumeration The property is not to be enumerated by a \c{for-in} enumeration.

    \value PropertyGetter The property is defined by a function which will be called to get the property value.

    \value PropertySetter The property is defined by a function which will be called to set the property value.

    \value QObjectMember This flag is used to indicate that an existing property is a QObject member (a property or method).

    \value KeepExistingFlags This value is used to indicate to setProperty() that the property's flags should be left unchanged. If the property doesn't exist, the default flags (0) will be used.

    \value UserRange Flags in this range are not used by Qt Script, and can be used for custom purposes.

*/

/*!

    \enum QScriptValue::ResolveFlag

    This enum specifies how to look up a property of an object.

    \value ResolveLocal Only check the object's own properties.

    \value ResolvePrototype Check the object's own properties first, then search the prototype chain. This is the default.

    \omitvalue ResolveScope Check the object's own properties first, then search the scope chain.

    \omitvalue ResolveFull Check the object's own properties first, then search the prototype chain, and finally search the scope chain.

*/

// ### move

#include <QtCore/qnumeric.h>

#include <math.h>

QT_BEGIN_NAMESPACE

namespace QScript

{

static const qsreal D32 = 4294967296.0;

qint32 ToInt32(qsreal n)

{

    if (qIsNaN(n) || qIsInf(n) || (n == 0))

        return 0;

    qsreal sign = (n < 0) ? -1.0 : 1.0;

    qsreal abs_n = fabs(n);

    n = ::fmod(sign * ::floor(abs_n), D32);

    const double D31 = D32 / 2.0;

    if (sign == -1 && n < -D31)

        n += D32;

    else if (sign != -1 && n >= D31)

        n -= D32;

    return qint32 (n);

}

quint32 ToUint32(qsreal n)

{

    if (qIsNaN(n) || qIsInf(n) || (n == 0))

        return 0;

    qsreal sign = (n < 0) ? -1.0 : 1.0;

    qsreal abs_n = fabs(n);

    n = ::fmod(sign * ::floor(abs_n), D32);

    if (n < 0)

        n += D32;

    return quint32 (n);

}

quint16 ToUint16(qsreal n)

{

    static const qsreal D16 = 65536.0;

    if (qIsNaN(n) || qIsInf(n) || (n == 0))

        return 0;

    qsreal sign = (n < 0) ? -1.0 : 1.0;

    qsreal abs_n = fabs(n);

    n = ::fmod(sign * ::floor(abs_n), D16);

    if (n < 0)

        n += D16;

    return quint16 (n);

}

qsreal ToInteger(qsreal n)

{

    if (qIsNaN(n))

        return 0;

    if (n == 0 || qIsInf(n))

        return n;

    int sign = n < 0 ? -1 : 1;

    return sign * ::floor(::fabs(n));

}

} // namespace QScript

QScriptValue QScriptValuePrivate::propertyHelper(const JSC::Identifier &id, int resolveMode) const

{

    JSC::JSValue result;

    if (!(resolveMode & QScriptValue::ResolvePrototype)) {

        // Look in the object's own properties

        JSC::ExecState *exec = engine->currentFrame;

        JSC::JSObject *object = JSC::asObject(jscValue);

        JSC::PropertySlot slot(object);

        if (object->getOwnPropertySlot(exec, id, slot))

            result = slot.getValue(exec, id);

    }

    if (!result && (resolveMode & QScriptValue::ResolveScope)) {

        // ### check if it's a function object and look in the scope chain

        QScriptValue scope = property(QString::fromLatin1("__qt_scope__"), QScriptValue::ResolveLocal);

        if (scope.isObject())

            result = engine->scriptValueToJSCValue(QScriptValuePrivate::get(scope)->property(id, resolveMode));

    }

    return engine->scriptValueFromJSCValue(result);

}

QScriptValue QScriptValuePrivate::propertyHelper(quint32 index, int resolveMode) const

{

    JSC::JSValue result;

    if (!(resolveMode & QScriptValue::ResolvePrototype)) {

        // Look in the object's own properties

        JSC::ExecState *exec = engine->currentFrame;

        JSC::JSObject *object = JSC::asObject(jscValue);

        JSC::PropertySlot slot(object);

        if (object->getOwnPropertySlot(exec, index, slot))

            result = slot.getValue(exec, index);

    }

    return engine->scriptValueFromJSCValue(result);

}

void QScriptValuePrivate::setProperty(const JSC::Identifier &id, const QScriptValue &value,

                                      const QScriptValue::PropertyFlags &flags)

{

    QScriptEnginePrivate *valueEngine = QScriptValuePrivate::getEngine(value);

    if (valueEngine && (valueEngine != engine)) {

        qWarning("QScriptValue::setProperty(%s) failed: "

                 "cannot set value created in a different engine",

                 qPrintable(QString(id.ustring())));

        return;

    }

    JSC::ExecState *exec = engine->currentFrame;

    JSC::JSValue jsValue = engine->scriptValueToJSCValue(value);

    JSC::JSObject *thisObject = JSC::asObject(jscValue);

    JSC::JSValue setter = thisObject->lookupSetter(exec, id);

    JSC::JSValue getter = thisObject->lookupGetter(exec, id);

    if ((flags & QScriptValue::PropertyGetter) || (flags & QScriptValue::PropertySetter)) {

        if (!jsValue) {

            // deleting getter/setter

            if ((flags & QScriptValue::PropertyGetter) && (flags & QScriptValue::PropertySetter)) {

                // deleting both: just delete the property

                thisObject->deleteProperty(exec, id, /*checkDontDelete=*/false);

            } else if (flags & QScriptValue::PropertyGetter) {

                // preserve setter, if there is one

                thisObject->deleteProperty(exec, id, /*checkDontDelete=*/false);

                if (setter && setter.isObject())

                    thisObject->defineSetter(exec, id, JSC::asObject(setter));

            } else { // flags & QScriptValue::PropertySetter

                // preserve getter, if there is one

                thisObject->deleteProperty(exec, id, /*checkDontDelete=*/false);

                if (getter && getter.isObject())

                    thisObject->defineGetter(exec, id, JSC::asObject(getter));

            }

        } else {

            if (jsValue.isObject()) { // ### should check if it has callData()

                // defining getter/setter

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

                    qWarning("QScriptValue::setProperty() failed: "

                             "cannot set getter or setter of native property `__proto__'");

                } else {

                    if (flags & QScriptValue::PropertyGetter)

                        thisObject->defineGetter(exec, id, JSC::asObject(jsValue));

                    if (flags & QScriptValue::PropertySetter)

                        thisObject->defineSetter(exec, id, JSC::asObject(jsValue));

                }

            } else {

                qWarning("QScriptValue::setProperty(): getter/setter must be a function");

            }

        }

    } else {

        // setting the value

        if (getter && getter.isObject() && !(setter && setter.isObject())) {

            qWarning("QScriptValue::setProperty() failed: "

                     "property '%s' has a getter but no setter",

                     qPrintable(QString(id.ustring())));

            return;

        }

        if (!jsValue) {

            // ### check if it's a getter/setter property

            thisObject->deleteProperty(exec, id, /*checkDontDelete=*/false);

        } else if (flags != QScriptValue::KeepExistingFlags) {

            if (thisObject->hasOwnProperty(exec, id))

                thisObject->deleteProperty(exec, id, /*checkDontDelete=*/false); // ### hmmm - can't we just update the attributes?

            unsigned attribs = 0;

            if (flags & QScriptValue::ReadOnly)

                attribs |= JSC::ReadOnly;

            if (flags & QScriptValue::SkipInEnumeration)

                attribs |= JSC::DontEnum;

            if (flags & QScriptValue::Undeletable)

                attribs |= JSC::DontDelete;

            attribs |= flags & QScriptValue::UserRange;

            thisObject->putWithAttributes(exec, id, jsValue, attribs);

        } else {

            JSC::PutPropertySlot slot;

            thisObject->put(exec, id, jsValue, slot);

        }

    }

}

QScriptValue::PropertyFlags QScriptValuePrivate::propertyFlags(const JSC::Identifier &id,

                                                               const QScriptValue::ResolveFlags &mode) const

{

    JSC::ExecState *exec = engine->currentFrame;

    JSC::JSObject *object = JSC::asObject(jscValue);

    unsigned attribs = 0;

    JSC::PropertyDescriptor descriptor;

    if (object->getOwnPropertyDescriptor(exec, id, descriptor))

        attribs = descriptor.attributes();

    else if (!object->getPropertyAttributes(exec, id, attribs)) {

        if ((mode & QScriptValue::ResolvePrototype) && object->prototype() && object->prototype().isObject()) {

            QScriptValue proto = engine->scriptValueFromJSCValue(object->prototype());

            return QScriptValuePrivate::get(proto)->propertyFlags(id, mode);

        }

        return 0;

    }

    QScriptValue::PropertyFlags result = 0;

    if (attribs & JSC::ReadOnly)

        result |= QScriptValue::ReadOnly;

    if (attribs & JSC::DontEnum)

        result |= QScriptValue::SkipInEnumeration;

    if (attribs & JSC::DontDelete)

        result |= QScriptValue::Undeletable;

    //We cannot rely on attribs JSC::Setter/Getter because they are not necesserly set by JSC (bug?)

    if (attribs & JSC::Getter || !object->lookupGetter(exec, id).isUndefinedOrNull())

        result |= QScriptValue::PropertyGetter;

    if (attribs & JSC::Setter || !object->lookupSetter(exec, id).isUndefinedOrNull())

        result |= QScriptValue::PropertySetter;

    if (attribs & QScript::QObjectMemberAttribute)

        result |= QScriptValue::QObjectMember;

    result |= QScriptValue::PropertyFlag(attribs & QScriptValue::UserRange);

    return result;

}

QVariant &QScriptValuePrivate::variantValue() const

{

    Q_ASSERT(jscValue.inherits(&QScriptObject::info));

    QScriptObjectDelegate *delegate = static_cast<QScriptObject*>(JSC::asObject(jscValue))->delegate();

    Q_ASSERT(delegate && (delegate->type() == QScriptObjectDelegate::Variant));

    return static_cast<QScript::QVariantDelegate*>(delegate)->value();

}

void QScriptValuePrivate::setVariantValue(const QVariant &value)

{

    Q_ASSERT(jscValue.inherits(&QScriptObject::info));

    QScriptObjectDelegate *delegate = static_cast<QScriptObject*>(JSC::asObject(jscValue))->delegate();

    Q_ASSERT(delegate && (delegate->type() == QScriptObjectDelegate::Variant));

    static_cast<QScript::QVariantDelegate*>(delegate)->setValue(value);

}

void QScriptValuePrivate::detachFromEngine()

{

    if (isJSC())

        jscValue = JSC::JSValue();

    engine = 0;

}

/*!

  \internal

*/

QScriptValue::QScriptValue(QScriptValuePrivate *d)

    : d_ptr(d)

{

}

/*!

  Constructs an invalid QScriptValue.

*/

QScriptValue::QScriptValue()

    : d_ptr(0)

{

}

/*!

  Destroys this QScriptValue.

*/

QScriptValue::~QScriptValue()

{

}

/*!

  Constructs a new QScriptValue that is a copy of \a other.

  Note that if \a other is an object (i.e., isObject() would return

  true), then only a reference to the underlying object is copied into

  the new script value (i.e., the object itself is not copied).

*/

QScriptValue::QScriptValue(const QScriptValue &other)

    : d_ptr(other.d_ptr)

{

}

/*!

  \obsolete

  Constructs a new QScriptValue with the special \a value and

  registers it with the script \a engine.

*/

QScriptValue::QScriptValue(QScriptEngine *engine, QScriptValue::SpecialValue value)

    : d_ptr(new (QScriptEnginePrivate::get(engine))QScriptValuePrivate(QScriptEnginePrivate::get(engine)))

{

    switch (value) {

    case NullValue:

        d_ptr->initFrom(JSC::jsNull());

        break;

    case UndefinedValue:

        d_ptr->initFrom(JSC::jsUndefined());

        break;

    }

}

/*!

  \obsolete

  \fn QScriptValue::QScriptValue(QScriptEngine *engine, bool value)

  Constructs a new QScriptValue with the boolean \a value and

  registers it with the script \a engine.

*/

QScriptValue::QScriptValue(QScriptEngine *engine, bool val)

    : d_ptr(new (QScriptEnginePrivate::get(engine))QScriptValuePrivate(QScriptEnginePrivate::get(engine)))

{

    d_ptr->initFrom(JSC::jsBoolean(val));

}

/*!

  \fn QScriptValue::QScriptValue(QScriptEngine *engine, int value)

  \obsolete

  Constructs a new QScriptValue with the integer \a value and

  registers it with the script \a engine.

*/

QScriptValue::QScriptValue(QScriptEngine *engine, int val)

    : d_ptr(new (QScriptEnginePrivate::get(engine))QScriptValuePrivate(QScriptEnginePrivate::get(engine)))

{

    if (engine) {

        JSC::ExecState *exec = d_ptr->engine->currentFrame;

        d_ptr->initFrom(JSC::jsNumber(exec, val));