diff options
Diffstat (limited to 'src/script/api/qscriptvalue.cpp')
| -rw-r--r-- | src/script/api/qscriptvalue.cpp | 2303 |
1 files changed, 2303 insertions, 0 deletions
diff --git a/src/script/api/qscriptvalue.cpp b/src/script/api/qscriptvalue.cpp new file mode 100644 index 0000000000..32c5095f48 --- /dev/null +++ b/src/script/api/qscriptvalue.cpp @@ -0,0 +1,2303 @@ +/**************************************************************************** +** +** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the $MODULE$ of the Qt Toolkit. +** +** $TROLLTECH_DUAL_LICENSE$ +** +****************************************************************************/ + +#include "qscriptvalue.h" + +#ifndef QT_NO_SCRIPT + +#include "qscriptvalue_p.h" +#include "qscriptengine.h" +#include "qscriptengine_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/qnumeric.h> + +#include "utils/qscriptdate_p.h" +#include "bridge/qscriptvariant_p.h" +#include "bridge/qscriptqobject_p.h" + +QT_BEGIN_NAMESPACE + +/*! + \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. + + \value ResolveScope Check the object's own properties first, then search the scope chain. + + \value 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> + +namespace QScript +{ + +static const qsreal D32 = 4294967296.0; + +qint32 ToInt32(qsreal n) +{ + if (qIsNaN(n) || qIsInf(n) || (n == 0)) + return 0; + + double 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; + + double 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; + + double 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 + +QScriptValuePrivate::QScriptValuePrivate() +{ + ref = 0; +} + +QScriptValuePrivate::~QScriptValuePrivate() +{ +} + +void QScriptValuePrivate::initFromJSCValue(JSC::JSValue value) +{ + type = JSC; + jscValue = value; + if (!JSC::JSImmediate::isImmediate(value)) { + Q_ASSERT(engine != 0); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + if (value != eng_p->globalObject) { + if (!eng_p->keepAliveValues.contains(value)) + eng_p->keepAliveValues[value] = 0; + eng_p->keepAliveValues[value].ref(); + } + } +} + +void QScriptValuePrivate::initFromNumber(double value) +{ + type = Number; + numberValue = value; +} + +void QScriptValuePrivate::initFromString(const QString &value) +{ + type = String; + stringValue = new QString(value); +} + +void QScriptValuePrivate::initFromJSCValue(QScriptValue &result, + QScriptEngine *engine, + JSC::JSValue value) +{ + Q_ASSERT(!result.isValid()); + result.d_ptr = new QScriptValuePrivate(); + result.d_ptr->engine = engine; + result.d_ptr->initFromJSCValue(value); + result.d_ptr->ref.ref(); +} + +bool QScriptValuePrivate::isJSC() const +{ + return (type == JSC); +} + +QScriptValuePrivate *QScriptValuePrivate::get(const QScriptValue &q) +{ + return q.d_ptr; +} + +namespace QScript +{ +JSC::UString qtStringToJSCUString(const QString &str); +QString qtStringFromJSCUString(const JSC::UString &str); +} + +QScriptValue QScriptValuePrivate::property(const QString &name, int resolveMode) const +{ + Q_ASSERT(type == JSC); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::UString jscName = QScript::qtStringToJSCUString(name); + JSC::Identifier id = JSC::Identifier(exec, jscName); + JSC::JSObject *object = jscValue.getObject(); + JSC::PropertySlot slot(const_cast<JSC::JSObject*>(object)); + JSC::JSValue result; + if (const_cast<JSC::JSObject*>(object)->getOwnPropertySlot(exec, id, slot)) { + result = slot.getValue(exec, id); + } else if ((resolveMode & QScriptValue::ResolvePrototype) + && const_cast<JSC::JSObject*>(object)->getPropertySlot(exec, id, slot)) { + result = slot.getValue(exec, id); + } + return eng_p->scriptValueFromJSCValue(result); +} + +QScriptValue QScriptValuePrivate::property(quint32 index, int resolveMode) const +{ + Q_ASSERT(type == JSC); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::JSObject *object = jscValue.getObject(); + JSC::PropertySlot slot(const_cast<JSC::JSObject*>(object)); + JSC::JSValue result; + if (const_cast<JSC::JSObject*>(object)->getOwnPropertySlot(exec, index, slot)) { + result = slot.getValue(exec, index); + } else if ((resolveMode & QScriptValue::ResolvePrototype) + && const_cast<JSC::JSObject*>(object)->getPropertySlot(exec, index, slot)) { + result = slot.getValue(exec, index); + } + return eng_p->scriptValueFromJSCValue(result); +} + +/*! + Constructs an invalid QScriptValue. +*/ +QScriptValue::QScriptValue() + : d_ptr(0) +{ +} + +/*! + Destroys this QScriptValue. +*/ +QScriptValue::~QScriptValue() +{ + if (d_ptr && !d_ptr->ref.deref()) { + if (d_ptr->engine && d_ptr->isJSC() + && !JSC::JSImmediate::isImmediate(d_ptr->jscValue)) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d_ptr->engine); + if (d_ptr->jscValue != eng_p->globalObject) + eng_p->releaseJSCValue(d_ptr->jscValue); + } + delete d_ptr; + d_ptr = 0; + } +} + +/*! + 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) +{ + if (d_ptr) + d_ptr->ref.ref(); +} + +/*! + \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 QScriptValuePrivate) +{ + d_ptr->engine = engine; + switch (value) { + case NullValue: + d_ptr->initFromJSCValue(JSC::jsNull()); + break; + case UndefinedValue: + d_ptr->initFromJSCValue(JSC::jsUndefined()); + break; + } + d_ptr->ref.ref(); +} + +/*! + \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 QScriptValuePrivate) +{ + d_ptr->engine = engine; + d_ptr->initFromJSCValue(JSC::jsBoolean(val)); + d_ptr->ref.ref(); +} + +/*! + \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 QScriptValuePrivate) +{ + d_ptr->engine = engine; + if (engine) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + d_ptr->initFromJSCValue(JSC::jsNumber(exec, val)); + } else { + JSC::JSValue immediate = JSC::JSImmediate::from(val); + if (immediate) + d_ptr->initFromJSCValue(immediate); + else + d_ptr->initFromNumber(val); + } + d_ptr->ref.ref(); +} + +/*! + \fn QScriptValue::QScriptValue(QScriptEngine *engine, uint value) + \obsolete + + Constructs a new QScriptValue with the unsigned integer \a value and + registers it with the script \a engine. + */ +QScriptValue::QScriptValue(QScriptEngine *engine, uint val) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = engine; + if (engine) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + d_ptr->initFromJSCValue(JSC::jsNumber(exec, val)); + } else { + JSC::JSValue immediate = JSC::JSImmediate::from(val); + if (immediate) + d_ptr->initFromJSCValue(immediate); + else + d_ptr->initFromNumber(val); + } + d_ptr->ref.ref(); +} + +/*! + \fn QScriptValue::QScriptValue(QScriptEngine *engine, qsreal value) + \obsolete + + Constructs a new QScriptValue with the qsreal \a value and + registers it with the script \a engine. +*/ +QScriptValue::QScriptValue(QScriptEngine *engine, qsreal val) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = engine; + if (engine) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + d_ptr->initFromJSCValue(JSC::jsNumber(exec, val)); + } else { + JSC::JSValue immediate = JSC::JSImmediate::from(val); + if (immediate) + d_ptr->initFromJSCValue(immediate); + else + d_ptr->initFromNumber(val); + } + d_ptr->ref.ref(); +} + +/*! + \fn QScriptValue::QScriptValue(QScriptEngine *engine, const QString &value) + \obsolete + + Constructs a new QScriptValue with the string \a value and + registers it with the script \a engine. +*/ +QScriptValue::QScriptValue(QScriptEngine *engine, const QString &val) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = engine; + if (engine) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::UString jscVal = QScript::qtStringToJSCUString(val); + d_ptr->initFromJSCValue(JSC::jsString(exec, jscVal)); + } else { + d_ptr->initFromString(val); + } + d_ptr->ref.ref(); +} + +/*! + \fn QScriptValue::QScriptValue(QScriptEngine *engine, const char *value) + \obsolete + + Constructs a new QScriptValue with the string \a value and + registers it with the script \a engine. +*/ + +#ifndef QT_NO_CAST_FROM_ASCII +QScriptValue::QScriptValue(QScriptEngine *engine, const char *val) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = engine; + if (engine) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + d_ptr->initFromJSCValue(JSC::jsString(exec, val)); + } else { + d_ptr->initFromString(QString::fromAscii(val)); + } + d_ptr->ref.ref(); +} +#endif + +/*! + \since 4.5 + + Constructs a new QScriptValue with a special \a value. +*/ +QScriptValue::QScriptValue(SpecialValue value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + switch (value) { + case NullValue: + d_ptr->initFromJSCValue(JSC::jsNull()); + break; + case UndefinedValue: + d_ptr->initFromJSCValue(JSC::jsUndefined()); + break; + } + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a boolean \a value. +*/ +QScriptValue::QScriptValue(bool value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + d_ptr->initFromJSCValue(JSC::jsBoolean(value)); + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a number \a value. +*/ +QScriptValue::QScriptValue(int value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + JSC::JSValue immediate = JSC::JSImmediate::from(value); + if (immediate) + d_ptr->initFromJSCValue(immediate); + else + d_ptr->initFromNumber(value); + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a number \a value. +*/ +QScriptValue::QScriptValue(uint value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + JSC::JSValue immediate = JSC::JSImmediate::from(value); + if (immediate) + d_ptr->initFromJSCValue(immediate); + else + d_ptr->initFromNumber(value); + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a number \a value. +*/ +QScriptValue::QScriptValue(qsreal value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + JSC::JSValue immediate = JSC::JSImmediate::from(value); + if (immediate) + d_ptr->initFromJSCValue(immediate); + else + d_ptr->initFromNumber(value); + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a string \a value. +*/ +QScriptValue::QScriptValue(const QString &value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + d_ptr->initFromString(value); + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a string \a value. +*/ +QScriptValue::QScriptValue(const QLatin1String &value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + d_ptr->initFromString(value); + d_ptr->ref.ref(); +} + +/*! + \since 4.5 + + Constructs a new QScriptValue with a string \a value. +*/ + +#ifndef QT_NO_CAST_FROM_ASCII +QScriptValue::QScriptValue(const char *value) + : d_ptr(new QScriptValuePrivate) +{ + d_ptr->engine = 0; + d_ptr->initFromString(QString::fromAscii(value)); + d_ptr->ref.ref(); +} +#endif + +/*! + Assigns the \a other value to this QScriptValue. + + Note that if \a other is an object (isObject() returns true), + only a reference to the underlying object will be assigned; + the object itself will not be copied. +*/ +QScriptValue &QScriptValue::operator=(const QScriptValue &other) +{ + if (d_ptr == other.d_ptr) + return *this; + if (d_ptr && !d_ptr->ref.deref()) { + if (d_ptr->engine && d_ptr->isJSC() + && !JSC::JSImmediate::isImmediate(d_ptr->jscValue)) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d_ptr->engine); + eng_p->releaseJSCValue(d_ptr->jscValue); + } + delete d_ptr; + } + d_ptr = other.d_ptr; + if (d_ptr) + d_ptr->ref.ref(); + return *this; +} + +/*! + Returns true if this QScriptValue is an object of the Error class; + otherwise returns false. + + \sa QScriptContext::throwError() +*/ +bool QScriptValue::isError() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + return static_cast<JSC::JSObject*>(d->jscValue.getObject())->isObject(&JSC::ErrorInstance::info); +} + +/*! + Returns true if this QScriptValue is an object of the Array class; + otherwise returns false. + + \sa QScriptEngine::newArray() +*/ +bool QScriptValue::isArray() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + return static_cast<JSC::JSObject*>(d->jscValue.getObject())->isObject(&JSC::JSArray::info); +} + +/*! + Returns true if this QScriptValue is an object of the Date class; + otherwise returns false. + + \sa QScriptEngine::newDate() +*/ +bool QScriptValue::isDate() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + return static_cast<JSC::JSObject*>(d->jscValue.getObject())->isObject(&JSC::DateInstance::info); +} + +/*! + Returns true if this QScriptValue is an object of the RegExp class; + otherwise returns false. + + \sa QScriptEngine::newRegExp() +*/ +bool QScriptValue::isRegExp() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + return static_cast<JSC::JSObject*>(d->jscValue.getObject())->isObject(&JSC::RegExpObject::info); +} + +/*! + If this QScriptValue is an object, returns the internal prototype + (\c{__proto__} property) of this object; otherwise returns an + invalid QScriptValue. + + \sa setPrototype(), isObject() +*/ +QScriptValue QScriptValue::prototype() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return QScriptValue(); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + return eng_p->scriptValueFromJSCValue(static_cast<JSC::JSObject*>(d->jscValue.getObject())->prototype()); +} + +/*! + If this QScriptValue is an object, sets the internal prototype + (\c{__proto__} property) of this object to be \a prototype; + otherwise does nothing. + + The internal prototype should not be confused with the public + property with name "prototype"; the public prototype is usually + only set on functions that act as constructors. + + \sa prototype(), isObject() +*/ +void QScriptValue::setPrototype(const QScriptValue &prototype) +{ + Q_D(QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return; + if (prototype.isValid() && prototype.engine() + && (prototype.engine() != engine())) { + qWarning("QScriptValue::setPrototype() failed: " + "cannot set a prototype created in " + "a different engine"); + return; + } + // ### check for cycle + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::JSValue other = eng_p->scriptValueToJSCValue(prototype); + static_cast<JSC::JSObject*>(d->jscValue.getObject())->setPrototype(other); +} + +/*! + \internal +*/ +QScriptValue QScriptValue::scope() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return QScriptValue(); + // ### make hidden property + return d->property(QLatin1String("__qt_scope__"), QScriptValue::ResolveLocal); +} + +/*! + \internal +*/ +void QScriptValue::setScope(const QScriptValue &scope) +{ + Q_D(QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return; + if (scope.isValid() && scope.engine() + && (scope.engine() != engine())) { + qWarning("QScriptValue::setScope() failed: " + "cannot set a scope object created in " + "a different engine"); + return; + } + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::JSValue other = eng_p->scriptValueToJSCValue(scope); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + // ### make hidden property + static_cast<JSC::JSObject*>(d->jscValue.getObject())->putDirect(JSC::Identifier(exec, "__qt_scope__"), other); +} + +/*! + Returns true if this QScriptValue is an instance of + \a other; otherwise returns false. + + This QScriptValue is considered to be an instance of \a other if + \a other is a function and the value of the \c{prototype} + property of \a other is in the prototype chain of this + QScriptValue. +*/ +bool QScriptValue::instanceOf(const QScriptValue &other) const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject() || !other.isObject()) + return false; + if (other.engine() != engine()) { + qWarning("QScriptValue::instanceof: " + "cannot perform operation on a value created in " + "a different engine"); + return false; + } + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::JSValue jscProto = eng_p->scriptValueToJSCValue(other.property(QLatin1String("prototype"))); + if (!jscProto) + return false; + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::JSValue jscOther = eng_p->scriptValueToJSCValue(other); + return static_cast<JSC::JSObject*>(jscOther.getObject())->hasInstance(exec, d->jscValue, jscProto); +} + +// ### move + +namespace QScript +{ + +enum Type { + Undefined, + Null, + Boolean, + String, + Number, + Object +}; + +static Type type(const QScriptValue &v) +{ + if (v.isUndefined()) + return Undefined; + else if (v.isNull()) + return Null; + else if (v.isBoolean()) + return Boolean; + else if (v.isString()) + return String; + else if (v.isNumber()) + return Number; + Q_ASSERT(v.isObject()); + return Object; +} + +QScriptValue ToPrimitive(const QScriptValue &object, JSC::PreferredPrimitiveType hint = JSC::NoPreference) +{ + Q_ASSERT(object.isObject()); + QScriptValuePrivate *pp = QScriptValuePrivate::get(object); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(pp->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + return eng_p->scriptValueFromJSCValue(static_cast<JSC::JSObject*>(pp->jscValue.getObject())->toPrimitive(exec, hint)); +} + +static bool IsNumerical(const QScriptValue &value) +{ + return value.isNumber() || value.isBool(); +} + +static bool LessThan(QScriptValue lhs, QScriptValue rhs) +{ + if (type(lhs) == type(rhs)) { + switch (type(lhs)) { + case Undefined: + case Null: + return false; + + case Number: +#if defined Q_CC_MSVC && !defined Q_CC_MSVC_NET + if (qIsNaN(lhs.toNumber()) || qIsNaN(rhs.toNumber())) + return false; +#endif + return lhs.toNumber() < rhs.toNumber(); + + case Boolean: + return lhs.toBool() < rhs.toBool(); + + case String: + return lhs.toString() < rhs.toString(); + + case Object: + break; + } // switch + } + + if (lhs.isObject()) + lhs = ToPrimitive(lhs, JSC::PreferNumber); + + if (rhs.isObject()) + rhs = ToPrimitive(rhs, JSC::PreferNumber); + + if (lhs.isString() && rhs.isString()) + return lhs.toString() < rhs.toString(); + + qsreal n1 = lhs.toNumber(); + qsreal n2 = rhs.toNumber(); +#if defined Q_CC_MSVC && !defined Q_CC_MSVC_NET + if (qIsNaN(n1) || qIsNaN(n2)) + return false; +#endif + return n1 < n2; +} + +static bool Equals(QScriptValue lhs, QScriptValue rhs) +{ + if (type(lhs) == type(rhs)) { + switch (type(lhs)) { + case QScript::Undefined: + case QScript::Null: + return true; + + case QScript::Number: + return lhs.toNumber() == rhs.toNumber(); + + case QScript::Boolean: + return lhs.toBool() == rhs.toBool(); + + case QScript::String: + return lhs.toString() == rhs.toString(); + + case QScript::Object: + if (lhs.isVariant()) + return lhs.strictlyEquals(rhs) || (lhs.toVariant() == rhs.toVariant()); +#ifndef QT_NO_QOBJECT + else if (lhs.isQObject()) + return (lhs.strictlyEquals(rhs)) || (lhs.toQObject() == rhs.toQObject()); +#endif + else + return lhs.strictlyEquals(rhs); + } + } + + if (lhs.isNull() && rhs.isUndefined()) + return true; + + else if (lhs.isUndefined() && rhs.isNull()) + return true; + + else if (IsNumerical(lhs) && rhs.isString()) + return lhs.toNumber() == rhs.toNumber(); + + else if (lhs.isString() && IsNumerical(rhs)) + return lhs.toNumber() == rhs.toNumber(); + + else if (lhs.isBool()) + return Equals(lhs.toNumber(), rhs); + + else if (rhs.isBool()) + return Equals(lhs, rhs.toNumber()); + + else if (lhs.isObject() && !rhs.isNull()) { + lhs = ToPrimitive(lhs); + + if (lhs.isValid() && !lhs.isObject()) + return Equals(lhs, rhs); + } + + else if (rhs.isObject() && ! lhs.isNull()) { + rhs = ToPrimitive(rhs); + if (rhs.isValid() && !rhs.isObject()) + return Equals(lhs, rhs); + } + + return false; +} + +} // namespace QScript + +/*! + Returns true if this QScriptValue is less than \a other, otherwise + returns false. The comparison follows the behavior described in + \l{ECMA-262} section 11.8.5, "The Abstract Relational Comparison + Algorithm". + + Note that if this QScriptValue or the \a other value are objects, + calling this function has side effects on the script engine, since + the engine will call the object's valueOf() function (and possibly + toString()) in an attempt to convert the object to a primitive value + (possibly resulting in an uncaught script exception). + + \sa equals() +*/ +bool QScriptValue::lessThan(const QScriptValue &other) const +{ + // no equivalent function in JSC? There's a jsLess() in VM/Machine.cpp + if (!isValid() || !other.isValid()) + return false; + if (other.engine() && engine() && (other.engine() != engine())) { + qWarning("QScriptValue::lessThan: " + "cannot compare to a value created in " + "a different engine"); + return false; + } + return QScript::LessThan(*this, other); +} + +/*! + Returns true if this QScriptValue is equal to \a other, otherwise + returns false. The comparison follows the behavior described in + \l{ECMA-262} section 11.9.3, "The Abstract Equality Comparison + Algorithm". + + This function can return true even if the type of this QScriptValue + is different from the type of the \a other value; i.e. the + comparison is not strict. For example, comparing the number 9 to + the string "9" returns true; comparing an undefined value to a null + value returns true; comparing a \c{Number} object whose primitive + value is 6 to a \c{String} object whose primitive value is "6" + returns true; and comparing the number 1 to the boolean value + \c{true} returns true. If you want to perform a comparison + without such implicit value conversion, use strictlyEquals(). + + Note that if this QScriptValue or the \a other value are objects, + calling this function has side effects on the script engine, since + the engine will call the object's valueOf() function (and possibly + toString()) in an attempt to convert the object to a primitive value + (possibly resulting in an uncaught script exception). + + \sa strictlyEquals(), lessThan() +*/ +bool QScriptValue::equals(const QScriptValue &other) const +{ + Q_D(const QScriptValue); + if (!d || !other.d_ptr) + return (d == other.d_ptr); + if (other.engine() && engine() && (other.engine() != engine())) { + qWarning("QScriptValue::equals: " + "cannot compare to a value created in " + "a different engine"); + return false; + } + if (d->isJSC() && other.d_ptr->isJSC()) { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + if (!eng_p) + eng_p = QScriptEnginePrivate::get(other.d_ptr->engine); + if (eng_p) { + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + Q_ASSERT_X(false, Q_FUNC_INFO, "implement me"); +#if 0 + if (JSC::equal(exec, d->jscValue, other.d_ptr->jscValue)) + return true; +#endif + } + } + return QScript::Equals(*this, other); +} + +/*! + Returns true if this QScriptValue is equal to \a other using strict + comparison (no conversion), otherwise returns false. The comparison + follows the behavior described in \l{ECMA-262} section 11.9.6, "The + Strict Equality Comparison Algorithm". + + If the type of this QScriptValue is different from the type of the + \a other value, this function returns false. If the types are equal, + the result depends on the type, as shown in the following table: + + \table + \header \o Type \o Result + \row \o Undefined \o true + \row \o Null \o true + \row \o Boolean \o true if both values are true, false otherwise + \row \o Number \o false if either value is NaN (Not-a-Number); true if values are equal, false otherwise + \row \o String \o true if both values are exactly the same sequence of characters, false otherwise + \row \o Object \o true if both values refer to the same object, false otherwise + \endtable + + \sa equals() +*/ +bool QScriptValue::strictlyEquals(const QScriptValue &other) const +{ + Q_D(const QScriptValue); + if (!d || !other.d_ptr) + return (d == other.d_ptr); + if (other.engine() && engine() && (other.engine() != engine())) { + qWarning("QScriptValue::strictlyEquals: " + "cannot compare to a value created in " + "a different engine"); + return false; + } + if (d->type != other.d_ptr->type) + return false; + switch (d->type) { + case QScriptValuePrivate::JSC: + return JSC::JSValue::strictEqual(d->jscValue, other.d_ptr->jscValue); + case QScriptValuePrivate::Number: + return (d->numberValue == other.d_ptr->numberValue); + case QScriptValuePrivate::String: + return (*d->stringValue == *other.d_ptr->stringValue); + } + return false; +} + +/*! + Returns the string value of this QScriptValue, as defined in + \l{ECMA-262} section 9.8, "ToString". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's toString() function (and possibly valueOf()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa isString() +*/ +QString QScriptValue::toString() const +{ + Q_D(const QScriptValue); + if (!d) + return QString(); + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + JSC::UString str = d->jscValue.toString(exec); + return QString(reinterpret_cast<const QChar*>(str.data()), str.size()); + } + case QScriptValuePrivate::Number: + return QScript::qtStringFromJSCUString(JSC::UString::from(d->numberValue)); + case QScriptValuePrivate::String: + return *d->stringValue; + } + return QString(); +} + +/*! + Returns the number value of this QScriptValue, as defined in + \l{ECMA-262} section 9.3, "ToNumber". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's valueOf() function (and possibly toString()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa isNumber(), toInteger(), toInt32(), toUInt32(), toUInt16() +*/ +qsreal QScriptValue::toNumber() const +{ + Q_D(const QScriptValue); + if (!d) + return 0; + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + return d->jscValue.toNumber(exec); + } + case QScriptValuePrivate::Number: + return d->numberValue; + case QScriptValuePrivate::String: + return QScript::qtStringToJSCUString(*d->stringValue).toDouble(); + } + return 0; +} + +/*! + \obsolete + + Use toBool() instead. +*/ +bool QScriptValue::toBoolean() const +{ + Q_D(const QScriptValue); + if (!d) + return false; + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + return d->jscValue.toBoolean(exec); + } + case QScriptValuePrivate::Number: + return (d->numberValue != 0) && !qIsNaN(d->numberValue); + case QScriptValuePrivate::String: + return (d->stringValue->length() != 0); + } + return false; +} + +/*! + \since 4.5 + + Returns the boolean value of this QScriptValue, using the conversion + rules described in \l{ECMA-262} section 9.2, "ToBoolean". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's valueOf() function (and possibly toString()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa isBool() +*/ +bool QScriptValue::toBool() const +{ + Q_D(const QScriptValue); + if (!d) + return false; + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + return d->jscValue.toBoolean(exec); + } + case QScriptValuePrivate::Number: + return (d->numberValue != 0) && !qIsNaN(d->numberValue); + case QScriptValuePrivate::String: + return (d->stringValue->length() != 0); + } + return false; +} + +/*! + Returns the signed 32-bit integer value of this QScriptValue, using + the conversion rules described in \l{ECMA-262} section 9.5, "ToInt32". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's valueOf() function (and possibly toString()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa toNumber(), toUInt32() +*/ +qint32 QScriptValue::toInt32() const +{ + Q_D(const QScriptValue); + if (!d) + return 0; + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + return d->jscValue.toInt32(exec); + } + case QScriptValuePrivate::Number: + return QScript::ToInt32(d->numberValue); + case QScriptValuePrivate::String: + return QScript::ToInt32(QScript::qtStringToJSCUString(*d->stringValue).toDouble()); + } + return 0; +} + +/*! + Returns the unsigned 32-bit integer value of this QScriptValue, using + the conversion rules described in \l{ECMA-262} section 9.6, "ToUint32". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's valueOf() function (and possibly toString()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa toNumber(), toInt32() +*/ +quint32 QScriptValue::toUInt32() const +{ + Q_D(const QScriptValue); + if (!d) + return 0; + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + return d->jscValue.toUInt32(exec); + } + case QScriptValuePrivate::Number: + return QScript::ToUint32(d->numberValue); + case QScriptValuePrivate::String: + return QScript::ToUint32(QScript::qtStringToJSCUString(*d->stringValue).toDouble()); + } + return 0; +} + +/*! + Returns the unsigned 16-bit integer value of this QScriptValue, using + the conversion rules described in \l{ECMA-262} section 9.7, "ToUint16". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's valueOf() function (and possibly toString()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa toNumber() +*/ +quint16 QScriptValue::toUInt16() const +{ + Q_D(const QScriptValue); + if (!d) + return 0; + switch (d->type) { + case QScriptValuePrivate::JSC: { + // no equivalent function in JSC + return QScript::ToUint16(toNumber()); + } + case QScriptValuePrivate::Number: + return QScript::ToUint16(d->numberValue); + case QScriptValuePrivate::String: + return QScript::ToUint16(QScript::qtStringToJSCUString(*d->stringValue).toDouble()); + } + return 0; +} + +/*! + Returns the integer value of this QScriptValue, using the conversion + rules described in \l{ECMA-262} section 9.4, "ToInteger". + + Note that if this QScriptValue is an object, calling this function + has side effects on the script engine, since the engine will call + the object's valueOf() function (and possibly toString()) in an + attempt to convert the object to a primitive value (possibly + resulting in an uncaught script exception). + + \sa toNumber() +*/ +qsreal QScriptValue::toInteger() const +{ + Q_D(const QScriptValue); + if (!d) + return 0; + switch (d->type) { + case QScriptValuePrivate::JSC: { + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p ? eng_p->globalObject->globalExec() : 0; + return d->jscValue.toInteger(exec); + } + case QScriptValuePrivate::Number: + return QScript::ToInteger(d->numberValue); + case QScriptValuePrivate::String: + return QScript::ToInteger(QScript::qtStringToJSCUString(*d->stringValue).toDouble()); + } + return 0; +} + +/*! + Returns the QVariant value of this QScriptValue, if it can be + converted to a QVariant; otherwise returns an invalid QVariant. + The conversion is performed according to the following table: + + \table + \header \o Input Type \o Result + \row \o Undefined \o An invalid QVariant. + \row \o Null \o An invalid QVariant. + \row \o Boolean \o A QVariant containing the value of the boolean. + \row \o Number \o A QVariant containing the value of the number. + \row \o String \o A QVariant containing the value of the string. + \row \o QVariant Object \o The result is the QVariant value of the object (no conversion). + \row \o QObject Object \o A QVariant containing a pointer to the QObject. + \row \o Date Object \o A QVariant containing the date value (toDateTime()). + \row \o RegExp Object \o A QVariant containing the regular expression value (toRegExp()). + \row \o Array Object \o The array is converted to a QVariantList. + \row \o Object \o If the value is primitive, then the result is converted to a QVariant according to the above rules; otherwise, an invalid QVariant is returned. + \endtable + + \sa isVariant() +*/ +QVariant QScriptValue::toVariant() const +{ + Q_D(const QScriptValue); + if (!d) + return QVariant(); + switch (d->type) { + case QScriptValuePrivate::JSC: + if (isObject()) { + if (isVariant()) + return static_cast<QScript::QVariantWrapperObject*>(d->jscValue.getObject())->value(); +#ifndef QT_NO_QOBJECT + else if (isQObject()) + return qVariantFromValue(toQObject()); +#endif + else if (isDate()) + return QVariant(toDateTime()); +#ifndef QT_NO_REGEXP + else if (isRegExp()) + return QVariant(toRegExp()); +#endif + else if (isArray()) + return QScriptEnginePrivate::variantListFromArray(*this); + // try to convert to primitive + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(engine()); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::JSValue prim = d->jscValue.toPrimitive(exec); + if (!prim.isObject()) + return eng_p->scriptValueFromJSCValue(prim).toVariant(); + } else if (isNumber()) { + return QVariant(toNumber()); + } else if (isString()) { + return QVariant(toString()); + } else if (isBool()) { + return QVariant(toBool()); + } + return QVariant(); + case QScriptValuePrivate::Number: + return QVariant(d->numberValue); + case QScriptValuePrivate::String: + return QVariant(*d->stringValue); + } + return QVariant(); +} + +/*! + \obsolete + + This function is obsolete; use QScriptEngine::toObject() instead. +*/ +QScriptValue QScriptValue::toObject() const +{ + Q_D(const QScriptValue); + if (!d || !d->engine) + return QScriptValue(); + switch (d->type) { + case QScriptValuePrivate::JSC: { + if (JSC::JSImmediate::isUndefinedOrNull(d->jscValue)) + return QScriptValue(); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + return eng_p->scriptValueFromJSCValue(d->jscValue.toObject(exec)); + } + case QScriptValuePrivate::Number: + case QScriptValuePrivate::String: + Q_ASSERT_X(false, Q_FUNC_INFO, "you should not get here"); + break; + } + return QScriptValue(); +} + +/*! + Returns a QDateTime representation of this value, in local time. + If this QScriptValue is not a date, or the value of the date is NaN + (Not-a-Number), an invalid QDateTime is returned. + + \sa isDate() +*/ +QDateTime QScriptValue::toDateTime() const +{ + Q_D(const QScriptValue); + if (!isDate()) + return QDateTime(); + qsreal t = static_cast<JSC::DateInstance*>(d->jscValue.getObject())->internalNumber(); + return QScript::ToDateTime(t, Qt::LocalTime); +} + +#ifndef QT_NO_REGEXP +/*! + Returns the QRegExp representation of this value. + If this QScriptValue is not a regular expression, an empty + QRegExp is returned. + + \sa isRegExp() +*/ +QRegExp QScriptValue::toRegExp() const +{ + Q_D(const QScriptValue); + if (!isRegExp()) + return QRegExp(); + QString pattern = d->property(QLatin1String("source"), QScriptValue::ResolvePrototype).toString(); + Qt::CaseSensitivity kase = Qt::CaseSensitive; + if (d->property(QLatin1String("ignoreCase"), QScriptValue::ResolvePrototype).toBool()) + kase = Qt::CaseInsensitive; + return QRegExp(pattern, kase, QRegExp::RegExp2); +} +#endif // QT_NO_REGEXP + +/*! + If this QScriptValue is a QObject, returns the QObject pointer + that the QScriptValue represents; otherwise, returns 0. + + If the QObject that this QScriptValue wraps has been deleted, + this function returns 0 (i.e. it is possible for toQObject() + to return 0 even when isQObject() returns true). + + \sa isQObject() +*/ +QObject *QScriptValue::toQObject() const +{ + Q_D(const QScriptValue); + if (isQObject()) { + return static_cast<QScript::QObjectWrapperObject*>(d->jscValue.getObject())->value(); + } else if (isVariant()) { + QVariant var = toVariant(); + int type = var.userType(); + if ((type == QMetaType::QObjectStar) || (type == QMetaType::QWidgetStar)) + return *reinterpret_cast<QObject* const *>(var.constData()); + } + return 0; +} + +/*! + If this QScriptValue is a QMetaObject, returns the QMetaObject pointer + that the QScriptValue represents; otherwise, returns 0. + + \sa isQMetaObject() +*/ +const QMetaObject *QScriptValue::toQMetaObject() const +{ + Q_ASSERT_X(false, Q_FUNC_INFO, "not implemented"); +// Q_D(const QScriptValue); +// if (isQMetaObject()) +// return static_cast<QScript::QMetaObjectWrapperObject*>(d->jscValue)->value(); + return 0; +} + +/*! + Sets the value of this QScriptValue's property with the given \a name to + the given \a value. + + If this QScriptValue is not an object, this function does nothing. + + If this QScriptValue does not already have a property with name \a name, + a new property is created; the given \a flags then specify how this + property may be accessed by script code. + + If \a value is invalid, the property is removed. + + If the property is implemented using a setter function (i.e. has the + PropertySetter flag set), calling setProperty() has side-effects on + the script engine, since the setter function will be called with the + given \a value as argument (possibly resulting in an uncaught script + exception). + + Note that you cannot specify custom getter or setter functions for + built-in properties, such as the \c{length} property of Array objects + or meta properties of QObject objects. + + \sa property() +*/ +void QScriptValue::setProperty(const QString &name, const QScriptValue &value, + const PropertyFlags &flags) +{ + Q_D(QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return; + if (value.engine() && (value.engine() != engine())) { + qWarning("QScriptValue::setProperty(%s) failed: " + "cannot set value created in a different engine", + qPrintable(name)); + return; + } + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::JSValue jscValue = eng_p->scriptValueToJSCValue(value); + JSC::UString jscName = QScript::qtStringToJSCUString(name); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::Identifier id = JSC::Identifier(exec, jscName); + if (!jscValue) { + static_cast<JSC::JSObject*>(d->jscValue.getObject())->deleteProperty(exec, id); + } else { + if ((flags & QScriptValue::PropertyGetter) || (flags & QScriptValue::PropertySetter)) { + if (jscValue.isObject()) { + if (flags & QScriptValue::PropertyGetter) + static_cast<JSC::JSObject*>(d->jscValue.getObject())->defineGetter(exec, id, static_cast<JSC::JSObject*>(jscValue.getObject())); + if (flags & QScriptValue::PropertySetter) + static_cast<JSC::JSObject*>(d->jscValue.getObject())->defineSetter(exec, id, static_cast<JSC::JSObject*>(jscValue.getObject())); + } + } else { + if (flags != QScriptValue::KeepExistingFlags) { + if (static_cast<JSC::JSObject*>(d->jscValue.getObject())->hasOwnProperty(exec, id)) + static_cast<JSC::JSObject*>(d->jscValue.getObject())->deleteProperty(exec, id); + 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; + static_cast<JSC::JSObject*>(d->jscValue.getObject())->putWithAttributes(exec, id, jscValue, attribs); + } else { + JSC::PutPropertySlot slot; + static_cast<JSC::JSObject*>(d->jscValue.getObject())->put(exec, id, jscValue, slot); + } + } + } +} + +/*! + Returns the value of this QScriptValue's property with the given \a name, + using the given \a mode to resolve the property. + + If no such property exists, an invalid QScriptValue is returned. + + If the property is implemented using a getter function (i.e. has the + PropertyGetter flag set), calling property() has side-effects on the + script engine, since the getter function will be called (possibly + resulting in an uncaught script exception). If an exception + occurred, property() returns the value that was thrown (typically + an \c{Error} object). + + \sa setProperty(), propertyFlags(), QScriptValueIterator +*/ +QScriptValue QScriptValue::property(const QString &name, + const ResolveFlags &mode) const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return QScriptValue(); + return d->property(name, mode); +} + +/*! + \overload + + Returns the property at the given \a arrayIndex, using the given \a + mode to resolve the property. + + This function is provided for convenience and performance when + working with array objects. + + If this QScriptValue is not an Array object, this function behaves + as if property() was called with the string representation of \a + arrayIndex. +*/ +QScriptValue QScriptValue::property(quint32 arrayIndex, + const ResolveFlags &mode) const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return QScriptValue(); + return d->property(arrayIndex, mode); +} + +/*! + \overload + + Sets the property at the given \a arrayIndex to the given \a value. + + This function is provided for convenience and performance when + working with array objects. + + If this QScriptValue is not an Array object, this function behaves + as if setProperty() was called with the string representation of \a + arrayIndex. +*/ +void QScriptValue::setProperty(quint32 arrayIndex, const QScriptValue &value, + const PropertyFlags &flags) +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return; + if (value.engine() && (value.engine() != engine())) { + qWarning("QScriptValue::setProperty() failed: " + "cannot set value created in a different engine"); + return; + } + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::JSValue jscValue = eng_p->scriptValueToJSCValue(value); + if (!jscValue) { + static_cast<JSC::JSObject*>(d->jscValue.getObject())->deleteProperty(exec, arrayIndex); + } else { + if ((flags & QScriptValue::PropertyGetter) || (flags & QScriptValue::PropertySetter)) { + Q_ASSERT_X(false, Q_FUNC_INFO, "property getters and setters not implemented"); + } else { + if (flags != QScriptValue::KeepExistingFlags) { +// if (static_cast<JSC::JSObject*>(d->jscValue->getObject())->hasOwnProperty(exec, arrayIndex)) +// static_cast<JSC::JSObject*>(d->jscValue->getObject())->deleteProperty(exec, arrayIndex); + 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; + static_cast<JSC::JSObject*>(d->jscValue.getObject())->putWithAttributes(exec, arrayIndex, jscValue, attribs); + } else { + static_cast<JSC::JSObject*>(d->jscValue.getObject())->put(exec, arrayIndex, jscValue); + } + } + } +} + +/*! + \since 4.4 + + Returns the value of this QScriptValue's property with the given \a name, + using the given \a mode to resolve the property. + + This overload of property() is useful when you need to look up the + same property repeatedly, since the lookup can be performed faster + when the name is represented as an interned string. + + \sa QScriptEngine::toStringHandle(), setProperty() +*/ +QScriptValue QScriptValue::property(const QScriptString &name, + const ResolveFlags &mode) const +{ + // ### simplified for now + return property(name.toString(), mode); +} + +/*! + \since 4.4 + + Sets the value of this QScriptValue's property with the given \a + name to the given \a value. The given \a flags specify how this + property may be accessed by script code. + + This overload of setProperty() is useful when you need to set the + same property repeatedly, since the operation can be performed + faster when the name is represented as an interned string. + + \sa QScriptEngine::toStringHandle() +*/ +void QScriptValue::setProperty(const QScriptString &name, + const QScriptValue &value, + const PropertyFlags &flags) +{ + // ### simplified for now + setProperty(name.toString(), value, flags); +} + +/*! + Returns the flags of the property with the given \a name, using the + given \a mode to resolve the property. + + \sa property() +*/ +QScriptValue::PropertyFlags QScriptValue::propertyFlags(const QString &name, + const ResolveFlags &mode) const +{ + Q_D(const QScriptValue); + if (!isObject()) + return 0; + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::UString jscName = QScript::qtStringToJSCUString(name); + JSC::Identifier id = JSC::Identifier(exec, jscName); + unsigned attribs = 0; + if (!static_cast<JSC::JSObject*>(d->jscValue.getObject())->getPropertyAttributes(exec, id, attribs)) + 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; + +// ### FIXME + Q_ASSERT_X(false, Q_FUNC_INFO, "not implemented"); +#if 0 + // ### faster/better way? + if (static_cast<JSC::JSObject*>(d->jscValue.getObject())->lookupGetter(exec, id) != 0) + result |= QScriptValue::PropertyGetter; + if (static_cast<JSC::JSObject*>(d->jscValue.getObject())->lookupSetter(exec, id) != 0) + result |= QScriptValue::PropertySetter; +#endif + + result |= QScriptValue::PropertyFlag(attribs & QScriptValue::UserRange); + return result; +} + +/*! + \since 4.4 + + Returns the flags of the property with the given \a name, using the + given \a mode to resolve the property. + + \sa property() +*/ +QScriptValue::PropertyFlags QScriptValue::propertyFlags(const QScriptString &name, + const ResolveFlags &mode) const +{ + // ### simplified for now + return propertyFlags(name.toString(), mode); +} + +/*! + Calls this QScriptValue as a function, using \a thisObject as + the `this' object in the function call, and passing \a args + as arguments to the function. Returns the value returned from + the function. + + If this QScriptValue is not a function, call() does nothing + and returns an invalid QScriptValue. + + Note that if \a thisObject is not an object, the global object + (see \l{QScriptEngine::globalObject()}) will be used as the + `this' object. + + Calling call() can cause an exception to occur in the script engine; + in that case, call() returns the value that was thrown (typically an + \c{Error} object). You can call + QScriptEngine::hasUncaughtException() to determine if an exception + occurred. + + \snippet doc/src/snippets/code/src_script_qscriptvalue.cpp 2 + + \sa construct() +*/ +QScriptValue QScriptValue::call(const QScriptValue &thisObject, + const QScriptValueList &args) +{ + Q_D(const QScriptValue); + if (!isFunction()) + return QScriptValue(); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::ArgList jscArgs; + for (int i = 0; i < args.size(); ++i) { + Q_ASSERT_X(false, Q_FUNC_INFO, "implement me"); +#if 0 + if (!args.at(i).isValid()) + jscArgs.append(JSC::jsUndefined()); + else + jscArgs.append(eng_p->scriptValueToJSCValue(args.at(i))); +#endif + } + JSC::JSValue jscThisObject = eng_p->scriptValueToJSCValue(thisObject); + if (!jscThisObject || !jscThisObject.isObject()) + jscThisObject = eng_p->globalObject; + JSC::JSValue result = static_cast<JSC::JSFunction*>(JSC::asFunction(d->jscValue))->call(exec, jscThisObject, jscArgs); + if (exec->hadException()) + result = exec->exception(); + return eng_p->scriptValueFromJSCValue(result); +} + +/*! + Calls this QScriptValue as a function, using \a thisObject as + the `this' object in the function call, and passing \a arguments + as arguments to the function. Returns the value returned from + the function. + + If this QScriptValue is not a function, call() does nothing + and returns an invalid QScriptValue. + + \a arguments can be an arguments object, an array, null or + undefined; any other type will cause a TypeError to be thrown. + + Note that if \a thisObject is not an object, the global object + (see \l{QScriptEngine::globalObject()}) will be used as the + `this' object. + + One common usage of this function is to forward native function + calls to another function: + + \snippet doc/src/snippets/code/src_script_qscriptvalue.cpp 3 + + \sa construct(), QScriptContext::argumentsObject() +*/ +QScriptValue QScriptValue::call(const QScriptValue &thisObject, + const QScriptValue &arguments) +{ + Q_D(QScriptValue); + if (!isFunction()) + return QScriptValue(); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + + JSC::JSValue jscThisObject = eng_p->scriptValueToJSCValue(thisObject); + if (!jscThisObject || !jscThisObject.isObject()) + jscThisObject = eng_p->globalObject; + + Q_ASSERT_X(false, Q_FUNC_INFO, "implement me"); +#if 0 + // copied from kjs/FunctionPrototype.cpp, functionProtoFuncApply() + JSC::JSValue argArray = eng_p->scriptValueToJSCValue(arguments); + JSC::ArgList applyArgs; + if (!argArray.isUndefinedOrNull()) { + if (argArray.isObject()) { + if (static_cast<JSC::JSObject*>(argArray.getObject())->classInfo() == &JSC::Arguments::info) + static_cast<JSC::Arguments*>(asArguments(argArray))->fillArgList(exec, applyArgs); + else if (exec->interpreter()->isJSArray(argArray)) + static_cast<JSC::JSArray*>(JSC::asArray(argArray))->fillArgList(exec, applyArgs); + else if (static_cast<JSC::JSObject*>(argArray.getObject())->inherits(&JSC::JSArray::info)) { + unsigned length = static_cast<JSC::JSObject*>(argArray.getObject())->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned i = 0; i < length; ++i) + applyArgs.append(static_cast<JSC::JSObject*>(argArray.getObject())->get(exec, i)); + } else + return QScriptValue(); // ### throwError(exec, TypeError); + } else + return QScriptValue(); // ### throwError(exec, TypeError); + } + + JSC::JSValue result = static_cast<JSC::JSFunction*>(asFunction(d->jscValue))->call(exec, jscThisObject, applyArgs); + if (exec->hadException()) + result = exec->exception(); + return eng_p->scriptValueFromJSCValue(result); +#endif +} + +/*! + Creates a new \c{Object} and calls this QScriptValue as a + constructor, using the created object as the `this' object and + passing \a args as arguments. If the return value from the + constructor call is an object, then that object is returned; + otherwise the default constructed object is returned. + + If this QScriptValue is not a function, construct() does nothing + and returns an invalid QScriptValue. + + Calling construct() can cause an exception to occur in the script + engine; in that case, construct() returns the value that was thrown + (typically an \c{Error} object). You can call + QScriptEngine::hasUncaughtException() to determine if an exception + occurred. + + \sa call(), QScriptEngine::newObject() +*/ +QScriptValue QScriptValue::construct(const QScriptValueList &args) +{ + Q_D(const QScriptValue); + if (!isFunction()) + return QScriptValue(); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + JSC::ArgList jscArgs; + for (int i = 0; i < args.size(); ++i) { +#if 0 + Q_ASSERT_X(false, Q_FUNC_INFO, "implement me"); + if (!args.at(i).isValid()) + jscArgs.append(JSC::jsUndefined()); + else + jscArgs.append(eng_p->scriptValueToJSCValue(args.at(i))); +#endif + } + JSC::JSValue result = static_cast<JSC::JSFunction*>(asFunction(d->jscValue))->construct(exec, jscArgs); + if (exec->hadException()) + result = exec->exception(); + return eng_p->scriptValueFromJSCValue(result); +} + +/*! + Creates a new \c{Object} and calls this QScriptValue as a + constructor, using the created object as the `this' object and + passing \a arguments as arguments. If the return value from the + constructor call is an object, then that object is returned; + otherwise the default constructed object is returned. + + If this QScriptValue is not a function, construct() does nothing + and returns an invalid QScriptValue. + + \a arguments can be an arguments object, an array, null or + undefined. Any other type will cause a TypeError to be thrown. + + \sa call(), QScriptEngine::newObject(), QScriptContext::argumentsObject() +*/ +QScriptValue QScriptValue::construct(const QScriptValue &arguments) +{ + Q_D(QScriptValue); + if (!isFunction()) + return QScriptValue(); + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + + Q_ASSERT_X(false, Q_FUNC_INFO, "implement me"); +#if 0 + // copied from kjs/FunctionPrototype.cpp, functionProtoFuncApply() + JSC::JSValue argArray = eng_p->scriptValueToJSCValue(arguments); + JSC::ArgList applyArgs; + if (!argArray.isUndefinedOrNull()) { + if (argArray.isObject()) { + if (static_cast<JSC::JSObject*>(argArray.getObject())->classInfo() == &JSC::Arguments::info) + static_cast<JSC::Arguments*>(JSC::asArguments(argArray))->fillArgList(exec, applyArgs); + else if (exec->interpreter()->isJSArray(argArray)) + static_cast<JSC::JSArray*>(JSC::asArray(argArray))->fillArgList(exec, applyArgs); + else if (static_cast<JSC::JSObject*>(argArray.getObject())->inherits(&JSC::JSArray::info)) { + unsigned length = static_cast<JSC::JSObject*>(argArray.getObject())->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned i = 0; i < length; ++i) + applyArgs.append(static_cast<JSC::JSObject*>(argArray.getObject())->get(exec, i)); + } else + return QScriptValue(); // ### throwError(exec, TypeError); + } else + return QScriptValue(); // ### throwError(exec, TypeError); + } + + JSC::JSValue result = static_cast<JSC::JSFunction*>(JSC::asFunction(d->jscValue))->construct(exec, applyArgs); + if (exec->hadException()) + result = exec->exception(); + return eng_p->scriptValueFromJSCValue(result); +#endif +} + +/*! + Returns the QScriptEngine that created this QScriptValue, + or 0 if this QScriptValue is invalid or the value is not + associated with a particular engine. +*/ +QScriptEngine *QScriptValue::engine() const +{ + Q_D(const QScriptValue); + if (!d) + return 0; + return d->engine; +} + +/*! + \obsolete + + Use isBool() instead. +*/ +bool QScriptValue::isBoolean() const +{ + Q_D(const QScriptValue); + return d && d->isJSC() && d->jscValue.isBoolean(); +} + +/*! + \since 4.5 + + Returns true if this QScriptValue is of the primitive type Boolean; + otherwise returns false. + + \sa toBool() +*/ +bool QScriptValue::isBool() const +{ + Q_D(const QScriptValue); + return d && d->isJSC() && d->jscValue.isBoolean(); +} + +/*! + Returns true if this QScriptValue is of the primitive type Number; + otherwise returns false. + + \sa toNumber() +*/ +bool QScriptValue::isNumber() const +{ + Q_D(const QScriptValue); + if (!d) + return false; + switch (d->type) { + case QScriptValuePrivate::JSC: + return d->jscValue.isNumber(); + case QScriptValuePrivate::Number: + return true; + case QScriptValuePrivate::String: + return false; + } + return false; +} + +/*! + Returns true if this QScriptValue is of the primitive type String; + otherwise returns false. + + \sa toString() +*/ +bool QScriptValue::isString() const +{ + Q_D(const QScriptValue); + if (!d) + return false; + switch (d->type) { + case QScriptValuePrivate::JSC: + return d->jscValue.isString(); + case QScriptValuePrivate::Number: + return false; + case QScriptValuePrivate::String: + return true; + } + return false; +} + +/*! + Returns true if this QScriptValue is a function; otherwise returns + false. + + \sa call() +*/ +bool QScriptValue::isFunction() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + JSC::CallData callData; + return (static_cast<JSC::JSObject*>(d->jscValue.getObject())->getCallData(callData) != JSC::CallTypeNone); +} + +/*! + Returns true if this QScriptValue is of the primitive type Null; + otherwise returns false. + + \sa QScriptEngine::nullValue() +*/ +bool QScriptValue::isNull() const +{ + Q_D(const QScriptValue); + return d && d->isJSC() && d->jscValue.isNull(); +} + +/*! + Returns true if this QScriptValue is of the primitive type Undefined; + otherwise returns false. + + \sa QScriptEngine::undefinedValue() +*/ +bool QScriptValue::isUndefined() const +{ + Q_D(const QScriptValue); + return d && d->isJSC() && d->jscValue.isUndefined(); +} + +/*! + Returns true if this QScriptValue is of the Object type; otherwise + returns false. + + Note that function values, variant values, and QObject values are + objects, so this function returns true for such values. + + \sa toObject(), QScriptEngine::newObject() +*/ +bool QScriptValue::isObject() const +{ + Q_D(const QScriptValue); + return d && d->isJSC() && d->jscValue.isObject(); +} + +/*! + Returns true if this QScriptValue is a variant value; + otherwise returns false. + + \sa toVariant(), QScriptEngine::newVariant() +*/ +bool QScriptValue::isVariant() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + return static_cast<JSC::JSObject*>(d->jscValue.getObject())->isObject(&QScript::QVariantWrapperObject::info); +} + +/*! + Returns true if this QScriptValue is a QObject; otherwise returns + false. + + Note: This function returns true even if the QObject that this + QScriptValue wraps has been deleted. + + \sa toQObject(), QScriptEngine::newQObject() +*/ +bool QScriptValue::isQObject() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + return static_cast<JSC::JSObject*>(d->jscValue.getObject())->isObject(&QScript::QObjectWrapperObject::info); +} + +/*! + Returns true if this QScriptValue is a QMetaObject; otherwise returns + false. + + \sa toQMetaObject(), QScriptEngine::newQMetaObject() +*/ +bool QScriptValue::isQMetaObject() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return false; + Q_ASSERT_X(false, Q_FUNC_INFO, "not implemented"); +// return static_cast<JSC::JSObject*>(d->jscValue->getObject())->isObject(&QScript::QMetaObjectWrapperObject::info); + return false; +} + +/*! + Returns true if this QScriptValue is valid; otherwise returns + false. +*/ +bool QScriptValue::isValid() const +{ + Q_D(const QScriptValue); + return (d != 0); +} + +/*! + \since 4.4 + + Returns the internal data of this QScriptValue object. QtScript uses + this property to store the primitive value of Date, String, Number + and Boolean objects. For other types of object, custom data may be + stored using setData(). +*/ +QScriptValue QScriptValue::data() const +{ + Q_D(const QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return QScriptValue(); + // ### make hidden property + return d->property(QLatin1String("__qt_data__"), QScriptValue::ResolveLocal); +} + +/*! + \since 4.4 + + Sets the internal \a data of this QScriptValue object. You can use + this function to set object-specific data that won't be directly + accessible to scripts, but may be retrieved in C++ using the data() + function. +*/ +void QScriptValue::setData(const QScriptValue &data) +{ + Q_D(QScriptValue); + if (!d || !d->isJSC() || !d->jscValue.isObject()) + return; + QScriptEnginePrivate *eng_p = QScriptEnginePrivate::get(d->engine); + JSC::JSValue other = eng_p->scriptValueToJSCValue(data); + JSC::ExecState *exec = eng_p->globalObject->globalExec(); + // ### make hidden property + static_cast<JSC::JSObject*>(d->jscValue.getObject())->putDirect(JSC::Identifier(exec, "__qt_data__"), other); +} + +/*! + \since 4.4 + + Returns the custom script class that this script object is an + instance of, or 0 if the object is not of a custom class. + + \sa setScriptClass() +*/ +QScriptClass *QScriptValue::scriptClass() const +{ + if (isObject()) + return 0; + // ### implement me + Q_ASSERT_X(false, Q_FUNC_INFO, "not implemented"); + return 0; +} + +/*! + \since 4.4 + + Sets the custom script class of this script object to \a scriptClass. + This can be used to "promote" a plain script object (e.g. created + by the "new" operator in a script, or by QScriptEngine::newObject() in C++) + to an object of a custom type. + + If \a scriptClass is 0, the object will be demoted to a plain + script object. + + \sa scriptClass(), setData() +*/ +void QScriptValue::setScriptClass(QScriptClass *scriptClass) +{ + Q_ASSERT_X(false, Q_FUNC_INFO, "not implemented"); + // no idea... use a "hidden" property? + Q_UNUSED(scriptClass); +} + +/*! + \internal + + Returns the ID of this object, or -1 if this QScriptValue is not an + object. + + \sa QScriptEngine::objectById() +*/ +qint64 QScriptValue::objectId() const +{ + if (!isObject()) + return -1; + Q_ASSERT_X(false, Q_FUNC_INFO, "not implemented"); + // lazily initialized mapping from JSObject* to id? + return -1; +} + +QT_END_NAMESPACE + +#endif // QT_NO_SCRIPT |