284     \value QtOwnership The standard Qt ownership rules apply, i.e. the associated object will never be explicitly deleted by the script engine. This is the default. (QObject ownership is explained in \l{Object Trees and Object Ownership}.)

   297     \value QtOwnership The standard Qt ownership rules apply, i.e. the

   285     \value ScriptOwnership The value is owned by the script environment. The associated data will be deleted when appropriate (i.e. after the garbage collector has discovered that there are no more live references to the value).

   298     associated object will never be explicitly deleted by the script

   286     \value AutoOwnership If the associated object has a parent, the Qt ownership rules apply (QtOwnership); otherwise, the object is owned by the script environment (ScriptOwnership).

   299     engine. This is the default. (QObject ownership is explained in

   300     \l{Object Trees & Ownership}.)

   301 

   302     \value ScriptOwnership The value is owned by the script

   303     environment. The associated data will be deleted when appropriate

   304     (i.e. after the garbage collector has discovered that there are no

   305     more live references to the value).

   306 

   307     \value AutoOwnership If the associated object has a parent, the Qt

   308     ownership rules apply (QtOwnership); otherwise, the object is

   309     owned by the script environment (ScriptOwnership).

   310 

   488             QScriptValue tmp = engine->scriptValueFromJSCValue(arg0);

   595             JSC::UString propertyName = QScriptEnginePrivate::toString(exec, arg1);

   489             QString propertyName(arg1.toString(exec));

   596             slot = QScriptEnginePrivate::property(exec, arg0, propertyName, QScriptValue::ResolvePrototype);

   490             slot = engine->scriptValueToJSCValue(tmp.property(propertyName, QScriptValue::ResolvePrototype));

   572             QScriptValue tmp = engine->scriptValueFromJSCValue(arg0);

   677             JSC::UString propertyName = QScriptEnginePrivate::toString(exec, arg1);

   573             QString propertyName = arg1.toString(exec);

   678             slot = QScriptEnginePrivate::property(exec, arg0, propertyName, QScriptValue::ResolvePrototype);

   574             slot = engine->scriptValueToJSCValue(tmp.property(propertyName, QScriptValue::ResolvePrototype));

   651     QString context(args.at(0).toString(exec));

   755     JSC::UString context = args.at(0).toString(exec);

   653     QString text(args.at(1).toString(exec));

   757     JSC::UString text = args.at(1).toString(exec);

   655     QString comment;

   759     JSC::UString comment;

   660         QString encStr(args.at(3).toString(exec));

   764         JSC::UString encStr = args.at(3).toString(exec);

   661         if (encStr == QLatin1String("CodecForTr"))

   765         if (encStr == "CodecForTr")

   663         else if (encStr == QLatin1String("UnicodeUTF8"))

   767         else if (encStr == "UnicodeUTF8")

   672     QString result;

   776     JSC::UString result;

   674     result = QCoreApplication::translate(context.toLatin1().constData(),

   778     result = QCoreApplication::translate(QScript::convertToLatin1(context).constData(),

   675                                          text.toLatin1().constData(),

   779                                          QScript::convertToLatin1(text).constData(),

   676                                          comment.toLatin1().constData(),

   780                                          QScript::convertToLatin1(comment).constData(),

   702     QString context;

   806     QScriptEnginePrivate *engine = scriptEngineFromExec(exec);

   807     JSC::UString context;

   705         JSC::ExecState *frame = exec->removeHostCallFrameFlag();

   810         JSC::ExecState *frame = exec->callerFrame()->removeHostCallFrameFlag();

   709                 context = QFileInfo(frame->codeBlock()->source()->url()).baseName();

   814                 context = engine->translationContextFromUrl(frame->codeBlock()->source()->url());

   716     QString text(args.at(0).toString(exec));

   821     JSC::UString text = args.at(0).toString(exec);

   718     QString comment;

   823     JSC::UString comment;

   725     QString result;

   830     JSC::UString result;

   727     result = QCoreApplication::translate(context.toLatin1().constData(),

   832     result = QCoreApplication::translate(QScript::convertToLatin1(context).constData(),

   728                                          text.toLatin1().constData(),

   833                                          QScript::convertToLatin1(text).constData(),

   729                                          comment.toLatin1().constData(),

   834                                          QScript::convertToLatin1(comment).constData(),

   795 

   900     JSC::IdentifierTable *oldTable = JSC::currentIdentifierTable();

   857 QScriptValue QScriptEnginePrivate::scriptValueFromVariant(const QVariant &v)

   967 QVariant QScriptEnginePrivate::jscValueToVariant(JSC::ExecState *exec, JSC::JSValue value, int targetType)

   858 {

   859     Q_Q(QScriptEngine);

   860     QScriptValue result = q->create(v.userType(), v.data());

   861     Q_ASSERT(result.isValid());

   862     return result;

   863 }

   864 

   865 QVariant QScriptEnginePrivate::scriptValueToVariant(const QScriptValue &value, int targetType)

   868     if (QScriptEnginePrivate::convert(value, targetType, v.data(), this))

   970     if (convertValue(exec, value, targetType, v.data()))

   871         return value.toVariant();

   973         return toVariant(exec, value);

   872     if (value.isVariant()) {

   974     if (isVariant(value)) {

   873         v = value.toVariant();

   975         v = variantValue(value);

   888 JSC::JSValue QScriptEnginePrivate::jscValueFromVariant(const QVariant &v)

   989 JSC::JSValue QScriptEnginePrivate::arrayFromStringList(JSC::ExecState *exec, const QStringList &lst)

   889 {

   990 {

   890     // ### it's inefficient to convert to QScriptValue and then to JSValue

   991     JSC::JSValue arr =  newArray(exec, lst.size());

   891     QScriptValue vv = scriptValueFromVariant(v);

   892     QScriptValuePrivate *p = QScriptValuePrivate::get(vv);

   893     switch (p->type) {

   894     case QScriptValuePrivate::JavaScriptCore:

   895         return p->jscValue;

   896     case QScriptValuePrivate::Number:

   897         return JSC::jsNumber(currentFrame, p->numberValue);

   898     case QScriptValuePrivate::String: {

   899         JSC::UString str = p->stringValue;

   900         return JSC::jsString(currentFrame, str);

   901       }

   902     }

   903     return JSC::JSValue();

   904 }

   905 

   906 QVariant QScriptEnginePrivate::jscValueToVariant(JSC::JSValue value, int targetType)

   907 {

   908     // ### it's inefficient to convert to QScriptValue and then to QVariant

   909     return scriptValueToVariant(scriptValueFromJSCValue(value), targetType);

   910 }

   911 

   912 QScriptValue QScriptEnginePrivate::arrayFromStringList(const QStringList &lst)

   913 {

   914     Q_Q(QScriptEngine);

   915     QScriptValue arr = q->newArray(lst.size());

   917         arr.setProperty(i, QScriptValue(q, lst.at(i)));

   993         setProperty(exec, arr, i, JSC::jsString(exec, lst.at(i)));

   921 QStringList QScriptEnginePrivate::stringListFromArray(const QScriptValue &arr)

   997 QStringList QScriptEnginePrivate::stringListFromArray(JSC::ExecState *exec, JSC::JSValue arr)

   924     uint len = arr.property(QLatin1String("length")).toUInt32();

  1000     uint len = toUInt32(exec, property(exec, arr, exec->propertyNames().length));

   926         lst.append(arr.property(i).toString());

  1002         lst.append(toString(exec, property(exec, arr, i)));

   930 QScriptValue QScriptEnginePrivate::arrayFromVariantList(const QVariantList &lst)

  1006 JSC::JSValue QScriptEnginePrivate::arrayFromVariantList(JSC::ExecState *exec, const QVariantList &lst)

   931 {

  1007 {

   932     Q_Q(QScriptEngine);

  1008     JSC::JSValue arr = newArray(exec, lst.size());

   933     QScriptValue arr = q->newArray(lst.size());

   935         arr.setProperty(i, scriptValueFromVariant(lst.at(i)));

  1010         setProperty(exec, arr, i, jscValueFromVariant(exec, lst.at(i)));

   939 QVariantList QScriptEnginePrivate::variantListFromArray(const QScriptValue &arr)

  1014 QVariantList QScriptEnginePrivate::variantListFromArray(JSC::ExecState *exec, JSC::JSValue arr)

   942     uint len = arr.property(QLatin1String("length")).toUInt32();

  1017     uint len = toUInt32(exec, property(exec, arr, exec->propertyNames().length));

   944         lst.append(arr.property(i).toVariant());

  1019         lst.append(toVariant(exec, property(exec, arr, i)));

   948 QScriptValue QScriptEnginePrivate::objectFromVariantMap(const QVariantMap &vmap)

  1023 JSC::JSValue QScriptEnginePrivate::objectFromVariantMap(JSC::ExecState *exec, const QVariantMap &vmap)

   949 {

  1024 {

   950     Q_Q(QScriptEngine);

  1025     JSC::JSValue obj = JSC::constructEmptyObject(exec);

   951     QScriptValue obj = q->newObject();

   954         obj.setProperty(it.key(), scriptValueFromVariant(it.value()));

  1028         setProperty(exec, obj, it.key(), jscValueFromVariant(exec, it.value()));

   958 QVariantMap QScriptEnginePrivate::variantMapFromObject(const QScriptValue &obj)

  1032 QVariantMap QScriptEnginePrivate::variantMapFromObject(JSC::ExecState *exec, JSC::JSValue obj)

   959 {

  1033 {

  1034     JSC::PropertyNameArray propertyNames(exec);

  1035     JSC::asObject(obj)->getOwnPropertyNames(exec, propertyNames, JSC::IncludeDontEnumProperties);

   961     QScriptValueIterator it(obj);

  1037     JSC::PropertyNameArray::const_iterator it = propertyNames.begin();

   962     while (it.hasNext()) {

  1038     for( ; it != propertyNames.end(); ++it)

   963         it.next();

  1039         vmap.insert(it->ustring(), toVariant(exec, property(exec, obj, *it)));

   964         vmap.insert(it.name(), it.value().toVariant());

   965     }

  1163     globalData->heap.collect();

  1237     QScript::APIShim shim(this);

  1238     globalData->heap.collectAllGarbage();

  1239 }

  1240 

  1241 void QScriptEnginePrivate::reportAdditionalMemoryCost(int size)

  1242 {

  1243     if (size > 0)

  1244         globalData->heap.reportExtraMemoryCost(size);

  1194     JSC::DynamicGlobalObjectScope dynamicGlobalObjectScope(exec, exec->scopeChain()->globalObject());

  1275     JSC::DynamicGlobalObjectScope dynamicGlobalObjectScope(exec, exec->scopeChain()->globalObject);

  1298 bool QScriptEnginePrivate::convertToNativeQObject(const QScriptValue &value,

  1379 bool QScriptEnginePrivate::convertToNativeQObject(JSC::ExecState *exec, JSC::JSValue value,

  1304     if (QObject *qobject = value.toQObject()) {

  1385     if (QObject *qobject = toQObject(exec, value)) {

  1608 /*!

  1530 JSC::JSValue QScriptEnginePrivate::newRegExp(JSC::ExecState *exec, const QRegExp &regexp)

  1609   Creates a QtScript object of class RegExp with the given

  1531 {

  1610   \a regexp.

  1611 

  1612   \sa QScriptValue::toRegExp()

  1613 */

  1614 QScriptValue QScriptEngine::newRegExp(const QRegExp &regexp)

  1615 {

  1616     Q_D(QScriptEngine);

  1617     JSC::ExecState* exec = d->currentFrame;

  1650                 break;

  1564                break;

  1665     JSC::JSObject* result = JSC::constructRegExp(exec, args);

  1579     return JSC::constructRegExp(exec, args);

  1666     return d->scriptValueFromJSCValue(result);

  1580 }

  1667 }

  1581 

  1668 

  1582 #endif

  1669 #endif // QT_NO_REGEXP

  1583 

  1670 

  1584 JSC::JSValue QScriptEnginePrivate::newRegExp(JSC::ExecState *exec, const QString &pattern, const QString &flags)

  1671 /*!

  1585 {

  1672   Creates a QtScript object holding the given variant \a value.

  1673 

  1674   If a default prototype has been registered with the meta type id of

  1675   \a value, then the prototype of the created object will be that

  1676   prototype; otherwise, the prototype will be the Object prototype

  1677   object.

  1678 

  1679   \sa setDefaultPrototype(), QScriptValue::toVariant()

  1680 */

  1681 QScriptValue QScriptEngine::newVariant(const QVariant &value)

  1682 {

  1683     Q_D(QScriptEngine);

  1684     JSC::ExecState* exec = d->currentFrame;

  1685     QScriptObject *obj = new (exec) QScriptObject(d->variantWrapperObjectStructure);

  1686     obj->setDelegate(new QScript::QVariantDelegate(value));

  1687     QScriptValue result = d->scriptValueFromJSCValue(obj);

  1688     QScriptValue proto = defaultPrototype(value.userType());

  1689     if (proto.isValid())

  1690         result.setPrototype(proto);

  1691     return result;

  1692 }

  1693 

  1694 /*!

  1695   \since 4.4

  1696   \overload

  1697 

  1698   Initializes the given Qt Script \a object to hold the given variant

  1699   \a value, and returns the \a object.

  1700 

  1701   This function enables you to "promote" a plain Qt Script object

  1702   (created by the newObject() function) to a variant, or to replace

  1703   the variant contained inside an object previously created by the

  1704   newVariant() function.

  1705 

  1706   The prototype() of the \a object will remain unchanged.

  1707 

  1708   If \a object is not an object, this function behaves like the normal

  1709   newVariant(), i.e. it creates a new script object and returns it.

  1710 

  1711   This function is useful when you want to provide a script

  1712   constructor for a C++ type. If your constructor is invoked in a

  1713   \c{new} expression (QScriptContext::isCalledAsConstructor() returns

  1714   true), you can pass QScriptContext::thisObject() (the default

  1715   constructed script object) to this function to initialize the new

  1716   object.

  1717 */

  1718 QScriptValue QScriptEngine::newVariant(const QScriptValue &object,

  1719                                        const QVariant &value)

  1720 {

  1721     if (!object.isObject())

  1722         return newVariant(value);

  1723     JSC::JSObject *jscObject = JSC::asObject(QScriptValuePrivate::get(object)->jscValue);

  1724     if (!jscObject->inherits(&QScriptObject::info)) {

  1725         qWarning("QScriptEngine::newVariant(): changing class of non-QScriptObject not supported");

  1726         return QScriptValue();

  1727     }

  1728     QScriptObject *jscScriptObject = static_cast<QScriptObject*>(jscObject);

  1729     if (!object.isVariant()) {

  1730         jscScriptObject->setDelegate(new QScript::QVariantDelegate(value));

  1731     } else {

  1732         QScriptValuePrivate::get(object)->setVariantValue(value);

  1733     }

  1734     return object;

  1735 }

  1736 

  1737 #ifndef QT_NO_QOBJECT

  1738 /*!

  1739   Creates a QtScript object that wraps the given QObject \a

  1740   object, using the given \a ownership. The given \a options control

  1741   various aspects of the interaction with the resulting script object.

  1742 

  1743   Signals and slots, properties and children of \a object are

  1744   available as properties of the created QScriptValue. For more

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

  1746 

  1747   If \a object is a null pointer, this function returns nullValue().

  1748 

  1749   If a default prototype has been registered for the \a object's class

  1750   (or its superclass, recursively), the prototype of the new script

  1751   object will be set to be that default prototype.

  1752 

  1753   If the given \a object is deleted outside of QtScript's control, any

  1754   attempt to access the deleted QObject's members through the QtScript

  1755   wrapper object (either by script code or C++) will result in a

  1756   script exception.

  1757 

  1758   \sa QScriptValue::toQObject()

  1759 */

  1760 QScriptValue QScriptEngine::newQObject(QObject *object, ValueOwnership ownership,

  1761                                        const QObjectWrapOptions &options)

  1762 {

  1763     Q_D(QScriptEngine);

  1764     JSC::JSValue jscQObject = d->newQObject(object, ownership, options);

  1765     return d->scriptValueFromJSCValue(jscQObject);

  1766 }

  1767 

  1768 /*!

  1769   \since 4.4

  1770   \overload

  1771 

  1772   Initializes the given \a scriptObject to hold the given \a qtObject,

  1773   and returns the \a scriptObject.

  1774 

  1775   This function enables you to "promote" a plain Qt Script object

  1776   (created by the newObject() function) to a QObject proxy, or to

  1777   replace the QObject contained inside an object previously created by

  1778   the newQObject() function.

  1779 

  1780   The prototype() of the \a scriptObject will remain unchanged.

  1781 

  1782   If \a scriptObject is not an object, this function behaves like the

  1783   normal newQObject(), i.e. it creates a new script object and returns

  1784   it.

  1785 

  1786   This function is useful when you want to provide a script

  1787   constructor for a QObject-based class. If your constructor is

  1788   invoked in a \c{new} expression

  1789   (QScriptContext::isCalledAsConstructor() returns true), you can pass

  1790   QScriptContext::thisObject() (the default constructed script object)

  1791   to this function to initialize the new object.

  1792 */

  1793 QScriptValue QScriptEngine::newQObject(const QScriptValue &scriptObject,

  1794                                        QObject *qtObject,

  1795                                        ValueOwnership ownership,

  1796                                        const QObjectWrapOptions &options)

  1797 {

  1798     if (!scriptObject.isObject())

  1799         return newQObject(qtObject, ownership, options);

  1800     JSC::JSObject *jscObject = JSC::asObject(QScriptValuePrivate::get(scriptObject)->jscValue);

  1801     if (!jscObject->inherits(&QScriptObject::info)) {

  1802         qWarning("QScriptEngine::newQObject(): changing class of non-QScriptObject not supported");

  1803         return QScriptValue();

  1804     }

  1805     QScriptObject *jscScriptObject = static_cast<QScriptObject*>(jscObject);

  1806     if (!scriptObject.isQObject()) {

  1807         jscScriptObject->setDelegate(new QScript::QObjectDelegate(qtObject, ownership, options));

  1808     } else {

  1809         QScript::QObjectDelegate *delegate = static_cast<QScript::QObjectDelegate*>(jscScriptObject->delegate());

  1810         delegate->setValue(qtObject);

  1811         delegate->setOwnership(ownership);

  1812         delegate->setOptions(options);

  1813     }

  1814     return scriptObject;

  1815 }

  1816 

  1817 #endif // QT_NO_QOBJECT

  1818 

  1819 /*!

  1820   Creates a QtScript object of class Object.

  1821 

  1822   The prototype of the created object will be the Object

  1823   prototype object.

  1824 

  1825   \sa newArray(), QScriptValue::setProperty()

  1826 */

  1827 QScriptValue QScriptEngine::newObject()

  1828 {

  1829     Q_D(QScriptEngine);

  1830     JSC::ExecState* exec = d->currentFrame;

  1831     JSC::JSObject *result = new (exec)QScriptObject(d->scriptObjectStructure);

  1832     return d->scriptValueFromJSCValue(result);

  1833 }

  1834 

  1835 /*!

  1836   \since 4.4

  1837   \overload

  1838 

  1839   Creates a QtScript Object of the given class, \a scriptClass.

  1840 

  1841   The prototype of the created object will be the Object

  1842   prototype object.

  1843 

  1844   \a data, if specified, is set as the internal data of the

  1845   new object (using QScriptValue::setData()).

  1846 

  1847   \sa QScriptValue::scriptClass()

  1848 */

  1849 QScriptValue QScriptEngine::newObject(QScriptClass *scriptClass,

  1850                                       const QScriptValue &data)

  1851 {

  1852     Q_D(QScriptEngine);

  1853     JSC::ExecState* exec = d->currentFrame;

  1854     QScriptObject *result = new (exec) QScriptObject(d->scriptObjectStructure);

  1855     result->setDelegate(new QScript::ClassObjectDelegate(scriptClass));

  1856     QScriptValue scriptObject = d->scriptValueFromJSCValue(result);

  1857     scriptObject.setData(data);

  1858     QScriptValue proto = scriptClass->prototype();

  1859     if (proto.isValid())

  1860         scriptObject.setPrototype(proto);

  1861     return scriptObject;

  1862 }

  1863 

  1864 /*!

  1865   \internal

  1866 */

  1867 QScriptValue QScriptEngine::newActivationObject()

  1868 {

  1869     qWarning("QScriptEngine::newActivationObject() not implemented");

  1870     // ### JSActivation or JSVariableObject?

  1871     return QScriptValue();

  1872 }

  1873 

  1874 /*!

  1875   Creates a QScriptValue that wraps a native (C++) function. \a fun

  1876   must be a C++ function with signature QScriptEngine::FunctionSignature.  \a

  1877   length is the number of arguments that \a fun expects; this becomes

  1878   the \c{length} property of the created QScriptValue.

  1879 

  1880   Note that \a length only gives an indication of the number of

  1881   arguments that the function expects; an actual invocation of a

  1882   function can include any number of arguments. You can check the

  1883   \l{QScriptContext::argumentCount()}{argumentCount()} of the

  1884   QScriptContext associated with the invocation to determine the

  1885   actual number of arguments passed.

  1886 

  1887   A \c{prototype} property is automatically created for the resulting

  1888   function object, to provide for the possibility that the function

  1889   will be used as a constructor.

  1890 

  1891   By combining newFunction() and the property flags

  1892   QScriptValue::PropertyGetter and QScriptValue::PropertySetter, you

  1893   can create script object properties that behave like normal

  1894   properties in script code, but are in fact accessed through

  1895   functions (analogous to how properties work in \l{Qt's Property

  1896   System}). Example:

  1897 

  1898   \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 11

  1899 

  1900   When the property \c{foo} of the script object is subsequently

  1901   accessed in script code, \c{getSetFoo()} will be invoked to handle

  1902   the access.  In this particular case, we chose to store the "real"

  1903   value of \c{foo} as a property of the accessor function itself; you

  1904   are of course free to do whatever you like in this function.

  1905 

  1906   In the above example, a single native function was used to handle

  1907   both reads and writes to the property; the argument count is used to

  1908   determine if we are handling a read or write. You can also use two

  1909   separate functions; just specify the relevant flag

  1910   (QScriptValue::PropertyGetter or QScriptValue::PropertySetter) when

  1911   setting the property, e.g.:

  1912 

  1913   \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 12

  1914 

  1915   \sa QScriptValue::call()

  1916 */

  1917 QScriptValue QScriptEngine::newFunction(QScriptEngine::FunctionSignature fun, int length)

  1918 {

  1919     Q_D(QScriptEngine);

  1920     JSC::ExecState* exec = d->currentFrame;

  1921     JSC::JSValue function = new (exec)QScript::FunctionWrapper(exec, length, JSC::Identifier(exec, ""), fun);

  1922     QScriptValue result = d->scriptValueFromJSCValue(function);

  1923     QScriptValue proto = newObject();

  1924     result.setProperty(QLatin1String("prototype"), proto, QScriptValue::Undeletable);

  1925     proto.setProperty(QLatin1String("constructor"), result,

  1926                       QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

  1927     return result;

  1928 }

  1929 

  1930 /*!

  1931   \internal

  1932   \since 4.4

  1933 */

  1934 QScriptValue QScriptEngine::newFunction(QScriptEngine::FunctionWithArgSignature fun, void *arg)

  1935 {

  1936     Q_D(QScriptEngine);

  1937     JSC::ExecState* exec = d->currentFrame;

  1938     JSC::JSValue function = new (exec)QScript::FunctionWithArgWrapper(exec, /*length=*/0, JSC::Identifier(exec, ""), fun, arg);

  1939     QScriptValue result = d->scriptValueFromJSCValue(function);

  1940     QScriptValue proto = newObject();

  1941     result.setProperty(QLatin1String("prototype"), proto, QScriptValue::Undeletable);

  1942     proto.setProperty(QLatin1String("constructor"), result,

  1943                       QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

  1944     return result;

  1945 }

  1946 

  1947 /*!

  1948   Creates a QtScript object of class Array with the given \a length.

  1949 

  1950   \sa newObject()

  1951 */

  1952 QScriptValue QScriptEngine::newArray(uint length)

  1953 {

  1954     Q_D(QScriptEngine);

  1955     JSC::ExecState* exec = d->currentFrame;

  1956     JSC::JSArray* result = JSC::constructEmptyArray(exec, length);

  1957     return d->scriptValueFromJSCValue(result);

  1958 }

  1959 

  1960 /*!

  1961   Creates a QtScript object of class RegExp with the given

  1962   \a pattern and \a flags.

  1963 

  1964   The legal flags are 'g' (global), 'i' (ignore case), and 'm'

  1965   (multiline).

  1966 */

  1967 QScriptValue QScriptEngine::newRegExp(const QString &pattern, const QString &flags)

  1968 {

  1969     Q_D(QScriptEngine);

  1970     JSC::ExecState* exec = d->currentFrame;

  1984     JSC::JSObject* result = JSC::constructRegExp(exec, args);

  1599     return JSC::constructRegExp(exec, args);

  1985     return d->scriptValueFromJSCValue(result);

  1600 }

  1601 

  1602 JSC::JSValue QScriptEnginePrivate::newVariant(const QVariant &value)

  1603 {

  1604     QScriptObject *obj = new (currentFrame) QScriptObject(variantWrapperObjectStructure);

  1605     obj->setDelegate(new QScript::QVariantDelegate(value));

  1606     JSC::JSValue proto = defaultPrototype(value.userType());

  1607     if (proto)

  1608         obj->setPrototype(proto);

  1609     return obj;

  1610 }

  1611 

  1612 JSC::JSValue QScriptEnginePrivate::newVariant(JSC::JSValue objectValue,

  1613                                               const QVariant &value)

  1614 {

  1615     if (!isObject(objectValue))

  1616         return newVariant(value);

  1617     JSC::JSObject *jscObject = JSC::asObject(objectValue);

  1618     if (!jscObject->inherits(&QScriptObject::info)) {

  1619         qWarning("QScriptEngine::newVariant(): changing class of non-QScriptObject not supported");

  1620         return JSC::JSValue();

  1621     }

  1622     QScriptObject *jscScriptObject = static_cast<QScriptObject*>(jscObject);

  1623     if (!isVariant(objectValue)) {

  1624         jscScriptObject->setDelegate(new QScript::QVariantDelegate(value));

  1625     } else {

  1626         setVariantValue(objectValue, value);

  1627     }

  1628     return objectValue;

  1629 }

  1630 

  1631 #ifndef QT_NO_REGEXP

  1632 

  1633 QRegExp QScriptEnginePrivate::toRegExp(JSC::ExecState *exec, JSC::JSValue value)

  1634 {

  1635     if (!isRegExp(value))

  1636         return QRegExp();

  1637     QString pattern = toString(exec, property(exec, value, "source", QScriptValue::ResolvePrototype));

  1638     Qt::CaseSensitivity kase = Qt::CaseSensitive;

  1639     if (toBool(exec, property(exec, value, "ignoreCase", QScriptValue::ResolvePrototype)))

  1640         kase = Qt::CaseInsensitive;

  1641     return QRegExp(pattern, kase, QRegExp::RegExp2);

  1642 }

  1643 

  1644 #endif

  1645 

  1646 QVariant QScriptEnginePrivate::toVariant(JSC::ExecState *exec, JSC::JSValue value)

  1647 {

  1648     if (!value) {

  1649         return QVariant();

  1650     } else if (isObject(value)) {

  1651         if (isVariant(value))

  1652             return variantValue(value);

  1653 #ifndef QT_NO_QOBJECT

  1654         else if (isQObject(value))

  1655             return qVariantFromValue(toQObject(exec, value));

  1656 #endif

  1657         else if (isDate(value))

  1658             return QVariant(toDateTime(exec, value));

  1659 #ifndef QT_NO_REGEXP

  1660         else if (isRegExp(value))

  1661             return QVariant(toRegExp(exec, value));

  1662 #endif

  1663         else if (isArray(value))

  1664             return variantListFromArray(exec, value);

  1665         else if (QScriptDeclarativeClass *dc = declarativeClass(value))

  1666             return dc->toVariant(declarativeObject(value));

  1667         // try to convert to primitive

  1668         JSC::JSValue savedException;

  1669         saveException(exec, &savedException);

  1670         JSC::JSValue prim = value.toPrimitive(exec);

  1671         restoreException(exec, savedException);

  1672         if (!prim.isObject())

  1673             return toVariant(exec, prim);

  1674     } else if (value.isNumber()) {

  1675         return QVariant(toNumber(exec, value));

  1676     } else if (value.isString()) {

  1677         return QVariant(toString(exec, value));

  1678     } else if (value.isBoolean()) {

  1679         return QVariant(toBool(exec, value));

  1680     }

  1681     return QVariant();

  1682 }

  1683 

  1684 JSC::JSValue QScriptEnginePrivate::propertyHelper(JSC::ExecState *exec, JSC::JSValue value, const JSC::Identifier &id, int resolveMode)

  1685 {

  1686     JSC::JSValue result;

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

  1688         // Look in the object's own properties

  1689         JSC::JSObject *object = JSC::asObject(value);

  1690         JSC::PropertySlot slot(object);

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

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

  1693     }

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

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

  1696         JSC::JSValue scope = property(exec, value, "__qt_scope__", QScriptValue::ResolveLocal);

  1697         if (isObject(scope))

  1698             result = property(exec, scope, id, resolveMode);

  1699     }

  1700     return result;

  1701 }

  1702 

  1703 JSC::JSValue QScriptEnginePrivate::propertyHelper(JSC::ExecState *exec, JSC::JSValue value, quint32 index, int resolveMode)

  1704 {

  1705     JSC::JSValue result;

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

  1707         // Look in the object's own properties

  1708         JSC::JSObject *object = JSC::asObject(value);

  1709         JSC::PropertySlot slot(object);

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

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

  1712     }

  1713     return result;