1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL-ONLY$

    10 ** GNU Lesser General Public License Usage

    11 ** This file may be used under the terms of the GNU Lesser

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

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

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

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

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

    17 **

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

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

    20 ** $QT_END_LICENSE$

    21 **

    22 ****************************************************************************/

    23 

    24 #include "config.h"

    25 #include "qscriptvalue.h"

    26 

    27 #include "qscriptvalue_p.h"

    28 #include "qscriptengine.h"

    29 #include "qscriptengine_p.h"

    30 #include "qscriptstring_p.h"

    31 

    32 #include "JSArray.h"

    33 #include "JSGlobalObject.h"

    34 #include "JSImmediate.h"

    35 #include "JSObject.h"

    36 #include "JSValue.h"

    37 #include "JSFunction.h"

    38 #include "DateInstance.h"

    39 #include "ErrorInstance.h"

    40 #include "RegExpObject.h"

    41 #include "Identifier.h"

    42 #include "Operations.h"

    43 #include "Arguments.h"

    44 

    45 #include <QtCore/qdatetime.h>

    46 #include <QtCore/qregexp.h>

    47 #include <QtCore/qvariant.h>

    48 #include <QtCore/qvarlengtharray.h>

    49 #include <QtCore/qnumeric.h>

    50 

    51 #include "utils/qscriptdate_p.h"

    52 #include "bridge/qscriptobject_p.h"

    53 #include "bridge/qscriptclassobject_p.h"

    54 #include "bridge/qscriptvariant_p.h"

    55 #include "bridge/qscriptqobject_p.h"

    56 #include "bridge/qscriptdeclarativeclass_p.h"

    57 #include "bridge/qscriptdeclarativeobject_p.h"

    58 

    59 /*!

    60   \since 4.3

    61   \class QScriptValue

    62 

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

    64 

    65   \ingroup script

    66   \mainclass

    67 

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

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

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

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

    72 

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

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

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

    76   use one of the QScriptValue constructor overloads.

    77 

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

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

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

    81   QScriptValue to another type. You can also use the generic

    82   qscriptvalue_cast() function.

    83 

    84   Object values have zero or more properties which are themselves

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

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

    87 

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

    89 

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

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

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

    93   following code snippet creates a property that cannot be modified by

    94   script code:

    95 

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

    97 

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

    99   the QScriptValueIterator class.

   100 

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

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

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

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

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

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

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

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

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

   110   create the property in the script object itself.  For more

   111   information, see the \l{QtScript} documentation.

   112 

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

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

   115   construct new objects by calling construct().

   116 

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

   118   to another.

   119 

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

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

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

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

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

   125   the "native" object data.

   126 

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

   128   reference to an actual object; copying the QScriptValue will only

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

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

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

   132   script code, or QScriptValueIterator in C++.

   133 

   134   \sa QScriptEngine, QScriptValueIterator

   135 */

   136 

   137 /*!

   138     \enum QScriptValue::SpecialValue

   139 

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

   141 

   142     \value UndefinedValue An undefined value.

   143 

   144     \value NullValue A null value.

   145 */

   146 

   147 /*!

   148     \enum QScriptValue::PropertyFlag

   149 

   150     This enum describes the attributes of a property.

   151 

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

   153 

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

   155 

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

   157 

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

   159 

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

   161 

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

   163 

   164     \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.

   165 

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

   167 */

   168 

   169 /*!

   170     \enum QScriptValue::ResolveFlag

   171 

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

   173 

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

   175 

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

   177 

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

   179 

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

   181 */

   182 

   183 // ### move

   184 

   185 #include <QtCore/qnumeric.h>

   186 #include <math.h>

   187 

   188 QT_BEGIN_NAMESPACE

   189 

   190 namespace QScript

   191 {

   192 

   193 static const qsreal D32 = 4294967296.0;

   194 

   195 qint32 ToInt32(qsreal n)

   196 {

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

   198         return 0;

   199 

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

   201     qsreal abs_n = fabs(n);

   202 

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

   204     const double D31 = D32 / 2.0;

   205 

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

   207         n += D32;

   208 

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

   210         n -= D32;

   211 

   212     return qint32 (n);

   213 }

   214 

   215 quint32 ToUint32(qsreal n)

   216 {

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

   218         return 0;

   219 

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

   221     qsreal abs_n = fabs(n);

   222 

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

   224 

   225     if (n < 0)

   226         n += D32;

   227 

   228     return quint32 (n);

   229 }

   230 

   231 quint16 ToUint16(qsreal n)

   232 {

   233     static const qsreal D16 = 65536.0;

   234 

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

   236         return 0;

   237 

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

   239     qsreal abs_n = fabs(n);

   240 

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

   242 

   243     if (n < 0)

   244         n += D16;

   245 

   246     return quint16 (n);

   247 }

   248 

   249 qsreal ToInteger(qsreal n)

   250 {

   251     if (qIsNaN(n))

   252         return 0;

   253 

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

   255         return n;

   256 

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

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

   259 }

   260 

   261 } // namespace QScript

   262 

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

   264 {

   265     JSC::JSValue result;

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

   267         // Look in the object's own properties

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

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

   270         JSC::PropertySlot slot(object);

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

   272             result = slot.getValue(exec, id);

   273     }

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

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

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

   277         if (scope.isObject())

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

   279     }

   280     return engine->scriptValueFromJSCValue(result);

   281 }

   282 

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

   284 {

   285     JSC::JSValue result;

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

   287         // Look in the object's own properties

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

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

   290         JSC::PropertySlot slot(object);

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

   292             result = slot.getValue(exec, index);

   293     }

   294     return engine->scriptValueFromJSCValue(result);

   295 }

   296 

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

   298                                       const QScriptValue::PropertyFlags &flags)

   299 {

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

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

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

   303                  "cannot set value created in a different engine",

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

   305         return;

   306     }

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

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

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

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

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

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

   313         if (!jsValue) {

   314             // deleting getter/setter

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

   316                 // deleting both: just delete the property

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

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

   319                 // preserve setter, if there is one

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

   321                 if (setter && setter.isObject())

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

   323             } else { // flags & QScriptValue::PropertySetter

   324                 // preserve getter, if there is one

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

   326                 if (getter && getter.isObject())

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

   328             }

   329         } else {

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

   331                 // defining getter/setter

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

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

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

   335                 } else {

   336                     if (flags & QScriptValue::PropertyGetter)

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

   338                     if (flags & QScriptValue::PropertySetter)

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

   340                 }

   341             } else {

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

   343             }

   344         }

   345     } else {

   346         // setting the value

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

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

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

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

   351             return;

   352         }

   353         if (!jsValue) {

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

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

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

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

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

   359             unsigned attribs = 0;

   360             if (flags & QScriptValue::ReadOnly)

   361                 attribs |= JSC::ReadOnly;

   362             if (flags & QScriptValue::SkipInEnumeration)

   363                 attribs |= JSC::DontEnum;

   364             if (flags & QScriptValue::Undeletable)

   365                 attribs |= JSC::DontDelete;

   366             attribs |= flags & QScriptValue::UserRange;

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

   368         } else {

   369             JSC::PutPropertySlot slot;

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

   371         }

   372     }

   373 }

   374 

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

   376                                                                const QScriptValue::ResolveFlags &mode) const

   377 {

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

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

   380     unsigned attribs = 0;

   381     JSC::PropertyDescriptor descriptor;

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

   383         attribs = descriptor.attributes();

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

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

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

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

   388         }

   389         return 0;

   390     }

   391     QScriptValue::PropertyFlags result = 0;

   392     if (attribs & JSC::ReadOnly)

   393         result |= QScriptValue::ReadOnly;

   394     if (attribs & JSC::DontEnum)

   395         result |= QScriptValue::SkipInEnumeration;

   396     if (attribs & JSC::DontDelete)

   397         result |= QScriptValue::Undeletable;

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

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

   400         result |= QScriptValue::PropertyGetter;

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

   402         result |= QScriptValue::PropertySetter;

   403     if (attribs & QScript::QObjectMemberAttribute)

   404         result |= QScriptValue::QObjectMember;

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

   406     return result;

   407 }

   408 

   409 QVariant &QScriptValuePrivate::variantValue() const

   410 {

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

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

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

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

   415 }

   416 

   417 void QScriptValuePrivate::setVariantValue(const QVariant &value)

   418 {

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

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

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

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

   423 }

   424 

   425 void QScriptValuePrivate::detachFromEngine()

   426 {

   427     if (isJSC())

   428         jscValue = JSC::JSValue();

   429     engine = 0;

   430 }

   431 

   432 /*!

   433   \internal

   434 */

   435 QScriptValue::QScriptValue(QScriptValuePrivate *d)

   436     : d_ptr(d)

   437 {

   438 }

   439 

   440 /*!

   441   Constructs an invalid QScriptValue.

   442 */

   443 QScriptValue::QScriptValue()

   444     : d_ptr(0)

   445 {

   446 }

   447 

   448 /*!

   449   Destroys this QScriptValue.

   450 */

   451 QScriptValue::~QScriptValue()

   452 {

   453 }

   454 

   455 /*!

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

   457 

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

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

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

   461 */

   462 QScriptValue::QScriptValue(const QScriptValue &other)

   463     : d_ptr(other.d_ptr)

   464 {

   465 }

   466 

   467 /*!

   468   \obsolete

   469 

   470   Constructs a new QScriptValue with the special \a value and

   471   registers it with the script \a engine.

   472 */

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

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

   475 {

   476     switch (value) {

   477     case NullValue:

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

   479         break;

   480     case UndefinedValue:

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

   482         break;

   483     }

   484 }

   485 

   486 /*!

   487   \obsolete

   488 

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

   490 

   491   Constructs a new QScriptValue with the boolean \a value and

   492   registers it with the script \a engine.

   493 */

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

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

   496 {

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

   498 }

   499 

   500 /*!

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

   502   \obsolete

   503 

   504   Constructs a new QScriptValue with the integer \a value and

   505   registers it with the script \a engine.

   506 */

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

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

   509 {

   510     if (engine) {

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

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

   513     } else

   514         d_ptr->initFrom(val);

   515 }

   516 

   517 /*!

   518   \fn QScriptValue::QScriptValue(QScriptEngine *engine, uint value)

   519   \obsolete

   520 

   521   Constructs a new QScriptValue with the unsigned integer \a value and

   522   registers it with the script \a engine.

   523  */

   524 QScriptValue::QScriptValue(QScriptEngine *engine, uint val)

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

   526 {

   527     if (engine) {

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

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

   530     } else

   531         d_ptr->initFrom(val);

   532 }

   533 

   534 /*!

   535   \fn QScriptValue::QScriptValue(QScriptEngine *engine, qsreal value)

   536   \obsolete

   537 

   538   Constructs a new QScriptValue with the qsreal \a value and

   539   registers it with the script \a engine.

   540 */

   541 QScriptValue::QScriptValue(QScriptEngine *engine, qsreal val)

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

   543 {

   544     if (engine) {

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

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

   547     } else

   548         d_ptr->initFrom(val);

   549 }

   550 

   551 /*!

   552   \fn QScriptValue::QScriptValue(QScriptEngine *engine, const QString &value)

   553   \obsolete

   554 

   555   Constructs a new QScriptValue with the string \a value and

   556   registers it with the script \a engine.

   557 */

   558 QScriptValue::QScriptValue(QScriptEngine *engine, const QString &val)

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

   560 {

   561     if (engine) {

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

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

   564     } else {

   565         d_ptr->initFrom(val);

   566     }

   567 }

   568 

   569 /*!

   570   \fn QScriptValue::QScriptValue(QScriptEngine *engine, const char *value)

   571   \obsolete

   572 

   573   Constructs a new QScriptValue with the string \a value and

   574   registers it with the script \a engine.

   575 */

   576 

   577 #ifndef QT_NO_CAST_FROM_ASCII

   578 QScriptValue::QScriptValue(QScriptEngine *engine, const char *val)

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

   580 {

   581     if (engine) {

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

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

   584     } else {

   585         d_ptr->initFrom(QString::fromAscii(val));

   586     }

   587 }

   588 #endif

   589 

   590 /*!

   591   \since 4.5

   592 

   593   Constructs a new QScriptValue with a special \a value.

   594 */

   595 QScriptValue::QScriptValue(SpecialValue value)

   596     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   597 {

   598     switch (value) {

   599     case NullValue:

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

   601         break;

   602     case UndefinedValue:

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

   604         break;

   605     }

   606 }

   607 

   608 /*!

   609   \since 4.5

   610 

   611   Constructs a new QScriptValue with a boolean \a value.

   612 */

   613 QScriptValue::QScriptValue(bool value)

   614     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   615 {

   616     d_ptr->initFrom(JSC::jsBoolean(value));

   617 }

   618 

   619 /*!

   620   \since 4.5

   621 

   622   Constructs a new QScriptValue with a number \a value.

   623 */

   624 QScriptValue::QScriptValue(int value)

   625     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   626 {

   627     d_ptr->initFrom(value);

   628 }

   629 

   630 /*!

   631   \since 4.5

   632 

   633   Constructs a new QScriptValue with a number \a value.

   634 */

   635 QScriptValue::QScriptValue(uint value)

   636     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   637 {

   638     d_ptr->initFrom(value);

   639 }

   640 

   641 /*!

   642   \since 4.5

   643 

   644   Constructs a new QScriptValue with a number \a value.

   645 */

   646 QScriptValue::QScriptValue(qsreal value)

   647     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   648 {

   649     d_ptr->initFrom(value);

   650 }

   651 

   652 /*!

   653   \since 4.5

   654 

   655   Constructs a new QScriptValue with a string \a value.

   656 */

   657 QScriptValue::QScriptValue(const QString &value)

   658     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   659 {

   660     d_ptr->initFrom(value);

   661 }

   662 

   663 /*!

   664   \since 4.5

   665 

   666   Constructs a new QScriptValue with a string \a value.

   667 */

   668 QScriptValue::QScriptValue(const QLatin1String &value)

   669     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   670 {

   671     d_ptr->initFrom(value);

   672 }

   673 

   674 /*!

   675   \since 4.5

   676 

   677   Constructs a new QScriptValue with a string \a value.

   678 */

   679 

   680 #ifndef QT_NO_CAST_FROM_ASCII

   681 QScriptValue::QScriptValue(const char *value)

   682     : d_ptr(new (/*engine=*/0)QScriptValuePrivate(/*engine=*/0))

   683 {

   684     d_ptr->initFrom(QString::fromAscii(value));

   685 }

   686 #endif

   687 

   688 /*!

   689   Assigns the \a other value to this QScriptValue.

   690 

   691   Note that if \a other is an object (isObject() returns true),

   692   only a reference to the underlying object will be assigned;

   693   the object itself will not be copied.

   694 */

   695 QScriptValue &QScriptValue::operator=(const QScriptValue &other)

   696 {

   697     d_ptr = other.d_ptr;

   698     return *this;

   699 }

   700 

   701 /*!

   702   Returns true if this QScriptValue is an object of the Error class;

   703   otherwise returns false.

   704 

   705   \sa QScriptContext::throwError()

   706 */

   707 bool QScriptValue::isError() const

   708 {

   709     Q_D(const QScriptValue);

   710     if (!d || !d->isObject())

   711         return false;

   712     return d->jscValue.inherits(&JSC::ErrorInstance::info);

   713 }

   714 

   715 /*!

   716   Returns true if this QScriptValue is an object of the Array class;

   717   otherwise returns false.

   718 

   719   \sa QScriptEngine::newArray()

   720 */

   721 bool QScriptValue::isArray() const

   722 {

   723     Q_D(const QScriptValue);

   724     if (!d || !d->isObject())

   725         return false;

   726     return d->jscValue.inherits(&JSC::JSArray::info);

   727 }

   728 

   729 /*!

   730   Returns true if this QScriptValue is an object of the Date class;

   731   otherwise returns false.

   732 

   733   \sa QScriptEngine::newDate()

   734 */

   735 bool QScriptValue::isDate() const

   736 {

   737     Q_D(const QScriptValue);

   738     if (!d || !d->isObject())

   739         return false;

   740     return d->jscValue.inherits(&JSC::DateInstance::info);

   741 }

   742 

   743 /*!

   744   Returns true if this QScriptValue is an object of the RegExp class;

   745   otherwise returns false.

   746 

   747   \sa QScriptEngine::newRegExp()

   748 */

   749 bool QScriptValue::isRegExp() const

   750 {

   751     Q_D(const QScriptValue);

   752     if (!d || !d->isObject())

   753         return false;

   754     return d->jscValue.inherits(&JSC::RegExpObject::info);

   755 }

   756 

   757 /*!

   758   If this QScriptValue is an object, returns the internal prototype

   759   (\c{__proto__} property) of this object; otherwise returns an

   760   invalid QScriptValue.

   761 

   762   \sa setPrototype(), isObject()

   763 */

   764 QScriptValue QScriptValue::prototype() const

   765 {

   766     Q_D(const QScriptValue);

   767     if (!d || !d->isObject())

   768         return QScriptValue();

   769     return d->engine->scriptValueFromJSCValue(JSC::asObject(d->jscValue)->prototype());

   770 }

   771 

   772 /*!

   773   If this QScriptValue is an object, sets the internal prototype

   774   (\c{__proto__} property) of this object to be \a prototype;

   775   otherwise does nothing.

   776 

   777   The internal prototype should not be confused with the public

   778   property with name "prototype"; the public prototype is usually

   779   only set on functions that act as constructors.

   780 

   781   \sa prototype(), isObject()

   782 */

   783 void QScriptValue::setPrototype(const QScriptValue &prototype)

   784 {

   785     Q_D(QScriptValue);

   786     if (!d || !d->isObject())

   787         return;

   788     if (prototype.isValid() && QScriptValuePrivate::getEngine(prototype)

   789         && (QScriptValuePrivate::getEngine(prototype) != d->engine)) {

   790         qWarning("QScriptValue::setPrototype() failed: "

   791                  "cannot set a prototype created in "

   792                  "a different engine");

   793         return;

   794     }

   795     JSC::JSValue other = d->engine->scriptValueToJSCValue(prototype);

   796 

   797     // check for cycle

   798     JSC::JSValue nextPrototypeValue = other;

   799     while (nextPrototypeValue && nextPrototypeValue.isObject()) {

   800         JSC::JSObject *nextPrototype = JSC::asObject(nextPrototypeValue);

   801         if (nextPrototype == JSC::asObject(d->jscValue)) {

   802             qWarning("QScriptValue::setPrototype() failed: cyclic prototype value");

   803             return;

   804         }

   805         nextPrototypeValue = nextPrototype->prototype();

   806     }

   807     JSC::asObject(d->jscValue)->setPrototype(other);

   808 }

   809 

   810 /*!

   811   \internal

   812 */

   813 QScriptValue QScriptValue::scope() const

   814 {

   815     Q_D(const QScriptValue);

   816     if (!d || !d->isObject())

   817         return QScriptValue();

   818     // ### make hidden property

   819     return d->property(QLatin1String("__qt_scope__"), QScriptValue::ResolveLocal);

   820 }

   821 

   822 /*!

   823   \internal

   824 */

   825 void QScriptValue::setScope(const QScriptValue &scope)

   826 {

   827     Q_D(QScriptValue);

   828     if (!d || !d->isObject())

   829         return;

   830     if (scope.isValid() && QScriptValuePrivate::getEngine(scope)

   831         && (QScriptValuePrivate::getEngine(scope) != d->engine)) {

   832         qWarning("QScriptValue::setScope() failed: "

   833                  "cannot set a scope object created in "

   834                  "a different engine");

   835         return;

   836     }

   837     JSC::JSValue other = d->engine->scriptValueToJSCValue(scope);

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

   839     JSC::Identifier id = JSC::Identifier(exec, "__qt_scope__");

   840     if (!scope.isValid()) {

   841         JSC::asObject(d->jscValue)->removeDirect(id);

   842     } else {

   843         // ### make hidden property

   844         JSC::asObject(d->jscValue)->putDirect(id, other);

   845     }

   846 }

   847 

   848 /*!

   849   Returns true if this QScriptValue is an instance of

   850   \a other; otherwise returns false.

   851 

   852   This QScriptValue is considered to be an instance of \a other if

   853   \a other is a function and the value of the \c{prototype}

   854   property of \a other is in the prototype chain of this

   855   QScriptValue.

   856 */

   857 bool QScriptValue::instanceOf(const QScriptValue &other) const

   858 {

   859     Q_D(const QScriptValue);

   860     if (!d || !d->isObject() || !other.isObject())

   861         return false;

   862     if (QScriptValuePrivate::getEngine(other) != d->engine) {

   863         qWarning("QScriptValue::instanceof: "

   864                  "cannot perform operation on a value created in "

   865                  "a different engine");

   866         return false;

   867     }

   868     JSC::JSValue jscProto = d->engine->scriptValueToJSCValue(other.property(QLatin1String("prototype")));

   869     if (!jscProto)

   870         jscProto = JSC::jsUndefined();

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

   872     JSC::JSValue jscOther = d->engine->scriptValueToJSCValue(other);

   873     return JSC::asObject(jscOther)->hasInstance(exec, d->jscValue, jscProto);

   874 }

   875 

   876 // ### move

   877 

   878 namespace QScript

   879 {

   880 

   881 enum Type {

   882     Undefined,

   883     Null,

   884     Boolean,

   885     String,

   886     Number,

   887     Object

   888 };

   889 

   890 static Type type(const QScriptValue &v)

   891 {

   892     if (v.isUndefined())

   893         return Undefined;

   894     else if (v.isNull())

   895         return Null;

   896     else if (v.isBoolean())

   897         return Boolean;

   898     else if (v.isString())

   899         return String;

   900     else if (v.isNumber())

   901         return Number;

   902     Q_ASSERT(v.isObject());

   903     return Object;

   904 }

   905 

   906 QScriptValue ToPrimitive(const QScriptValue &object, JSC::PreferredPrimitiveType hint = JSC::NoPreference)

   907 {

   908     Q_ASSERT(object.isObject());

   909     QScriptValuePrivate *pp = QScriptValuePrivate::get(object);

   910     Q_ASSERT(pp->engine != 0);

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

   912     JSC::JSValue savedException;

   913     QScriptValuePrivate::saveException(exec, &savedException);

   914     JSC::JSValue result = JSC::asObject(pp->jscValue)->toPrimitive(exec, hint);

   915     QScriptValuePrivate::restoreException(exec, savedException);

   916     return pp->engine->scriptValueFromJSCValue(result);

   917 }

   918 

   919 static bool IsNumerical(const QScriptValue &value)

   920 {

   921     return value.isNumber() || value.isBool();

   922 }

   923 

   924 static bool LessThan(QScriptValue lhs, QScriptValue rhs)

   925 {

   926     if (type(lhs) == type(rhs)) {

   927         switch (type(lhs)) {

   928         case Undefined:

   929         case Null:

   930             return false;

   931 

   932         case Number:

   933 #if defined Q_CC_MSVC && !defined Q_CC_MSVC_NET

   934             if (qIsNaN(lhs.toNumber()) || qIsNaN(rhs.toNumber()))

   935                 return false;

   936 #endif

   937             return lhs.toNumber() < rhs.toNumber();

   938 

   939         case Boolean:

   940             return lhs.toBool() < rhs.toBool();

   941 

   942         case String:

   943             return lhs.toString() < rhs.toString();

   944 

   945         case Object:

   946             break;

   947         } // switch

   948     }

   949 

   950     if (lhs.isObject())

   951         lhs = ToPrimitive(lhs, JSC::PreferNumber);

   952 

   953     if (rhs.isObject())

   954         rhs = ToPrimitive(rhs, JSC::PreferNumber);

   955 

   956     if (lhs.isString() && rhs.isString())

   957         return lhs.toString() < rhs.toString();

   958 

   959     qsreal n1 = lhs.toNumber();

   960     qsreal n2 = rhs.toNumber();

   961 #if defined Q_CC_MSVC && !defined Q_CC_MSVC_NET

   962     if (qIsNaN(n1) || qIsNaN(n2))

   963         return false;

   964 #endif

   965     return n1 < n2;

   966 }

   967 

   968 static bool Equals(QScriptValue lhs, QScriptValue rhs)

   969 {

   970     if (type(lhs) == type(rhs)) {

   971         switch (type(lhs)) {

   972         case QScript::Undefined:

   973         case QScript::Null:

   974             return true;

   975 

   976         case QScript::Number:

   977             return lhs.toNumber() == rhs.toNumber();

   978 

   979         case QScript::Boolean:

   980             return lhs.toBool() == rhs.toBool();

   981 

   982         case QScript::String:

   983             return lhs.toString() == rhs.toString();

   984 

   985         case QScript::Object:

   986             if (lhs.isVariant())

   987                 return lhs.strictlyEquals(rhs) || (lhs.toVariant() == rhs.toVariant());

   988 #ifndef QT_NO_QOBJECT

   989             else if (lhs.isQObject())

   990                 return (lhs.strictlyEquals(rhs)) || (lhs.toQObject() == rhs.toQObject());

   991 #endif

   992             else

   993                 return lhs.strictlyEquals(rhs);

   994         }

   995     }

   996 

   997     if (lhs.isNull() && rhs.isUndefined())

   998         return true;

   999 

  1000     else if (lhs.isUndefined() && rhs.isNull())

  1001         return true;

  1002 

  1003     else if (IsNumerical(lhs) && rhs.isString())

  1004         return lhs.toNumber() == rhs.toNumber();

  1005 

  1006     else if (lhs.isString() && IsNumerical(rhs))

  1007         return lhs.toNumber() == rhs.toNumber();

  1008 

  1009     else if (lhs.isBool())

  1010         return Equals(lhs.toNumber(), rhs);

  1011 

  1012     else if (rhs.isBool())

  1013         return Equals(lhs, rhs.toNumber());

  1014 

  1015     else if (lhs.isObject() && !rhs.isNull()) {

  1016         lhs = ToPrimitive(lhs);

  1017 

  1018         if (lhs.isValid() && !lhs.isObject())

  1019             return Equals(lhs, rhs);

  1020     }

  1021 

  1022     else if (rhs.isObject() && ! lhs.isNull()) {

  1023         rhs = ToPrimitive(rhs);

  1024         if (rhs.isValid() && !rhs.isObject())

  1025             return Equals(lhs, rhs);

  1026     }

  1027 

  1028     return false;

  1029 }

  1030 

  1031 } // namespace QScript

  1032 

  1033 /*!

  1034   Returns true if this QScriptValue is less than \a other, otherwise

  1035   returns false.  The comparison follows the behavior described in

  1036   \l{ECMA-262} section 11.8.5, "The Abstract Relational Comparison

  1037   Algorithm".

  1038 

  1039   Note that if this QScriptValue or the \a other value are objects,

  1040   calling this function has side effects on the script engine, since

  1041   the engine will call the object's valueOf() function (and possibly

  1042   toString()) in an attempt to convert the object to a primitive value

  1043   (possibly resulting in an uncaught script exception).

  1044 

  1045   \sa equals()

  1046 */

  1047 bool QScriptValue::lessThan(const QScriptValue &other) const

  1048 {

  1049     Q_D(const QScriptValue);

  1050     // no equivalent function in JSC? There's a jsLess() in VM/Machine.cpp

  1051     if (!isValid() || !other.isValid())

  1052         return false;

  1053     if (QScriptValuePrivate::getEngine(other) && d->engine

  1054         && (QScriptValuePrivate::getEngine(other) != d->engine)) {

  1055         qWarning("QScriptValue::lessThan: "

  1056                  "cannot compare to a value created in "

  1057                  "a different engine");

  1058         return false;

  1059     }

  1060     return QScript::LessThan(*this, other);

  1061 }

  1062 

  1063 /*!

  1064   Returns true if this QScriptValue is equal to \a other, otherwise

  1065   returns false. The comparison follows the behavior described in

  1066   \l{ECMA-262} section 11.9.3, "The Abstract Equality Comparison

  1067   Algorithm".

  1068 

  1069   This function can return true even if the type of this QScriptValue

  1070   is different from the type of the \a other value; i.e. the

  1071   comparison is not strict.  For example, comparing the number 9 to

  1072   the string "9" returns true; comparing an undefined value to a null

  1073   value returns true; comparing a \c{Number} object whose primitive

  1074   value is 6 to a \c{String} object whose primitive value is "6"

  1075   returns true; and comparing the number 1 to the boolean value

  1076   \c{true} returns true. If you want to perform a comparison

  1077   without such implicit value conversion, use strictlyEquals().

  1078 

  1079   Note that if this QScriptValue or the \a other value are objects,

  1080   calling this function has side effects on the script engine, since

  1081   the engine will call the object's valueOf() function (and possibly

  1082   toString()) in an attempt to convert the object to a primitive value

  1083   (possibly resulting in an uncaught script exception).

  1084 

  1085   \sa strictlyEquals(), lessThan()

  1086 */

  1087 bool QScriptValue::equals(const QScriptValue &other) const

  1088 {

  1089     Q_D(const QScriptValue);

  1090     if (!d || !other.d_ptr)

  1091         return (d_ptr == other.d_ptr);

  1092     if (QScriptValuePrivate::getEngine(other) && d->engine

  1093         && (QScriptValuePrivate::getEngine(other) != d->engine)) {

  1094         qWarning("QScriptValue::equals: "

  1095                  "cannot compare to a value created in "

  1096                  "a different engine");

  1097         return false;

  1098     }

  1099     if (d->isJSC() && other.d_ptr->isJSC()) {

  1100         QScriptEnginePrivate *eng_p = d->engine;

  1101         if (!eng_p)

  1102             eng_p = other.d_ptr->engine;

  1103         if (eng_p) {

  1104             JSC::ExecState *exec = eng_p->currentFrame;

  1105             JSC::JSValue savedException;

  1106             QScriptValuePrivate::saveException(exec, &savedException);

  1107             bool result = JSC::JSValue::equal(exec, d->jscValue, other.d_ptr->jscValue);

  1108             QScriptValuePrivate::restoreException(exec, savedException);

  1109             return result;

  1110         }

  1111     }

  1112     return QScript::Equals(*this, other);

  1113 }

  1114 

  1115 /*!

  1116   Returns true if this QScriptValue is equal to \a other using strict

  1117   comparison (no conversion), otherwise returns false. The comparison

  1118   follows the behavior described in \l{ECMA-262} section 11.9.6, "The

  1119   Strict Equality Comparison Algorithm".

  1120 

  1121   If the type of this QScriptValue is different from the type of the

  1122   \a other value, this function returns false. If the types are equal,

  1123   the result depends on the type, as shown in the following table:

  1124 

  1125     \table

  1126     \header \o Type \o Result

  1127     \row    \o Undefined  \o true

  1128     \row    \o Null       \o true

  1129     \row    \o Boolean    \o true if both values are true, false otherwise

  1130     \row    \o Number     \o false if either value is NaN (Not-a-Number); true if values are equal, false otherwise

  1131     \row    \o String     \o true if both values are exactly the same sequence of characters, false otherwise

  1132     \row    \o Object     \o true if both values refer to the same object, false otherwise

  1133     \endtable

  1134 

  1135   \sa equals()