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

     2 **

     3 ** Copyright (C) 2009 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$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "config.h"

    43 #include "qscriptqobject_p.h"

    44 

    45 #include <QtCore/qmetaobject.h>

    46 #include <QtCore/qvarlengtharray.h>

    47 #include <QtCore/qdebug.h>

    48 #include <QtScript/qscriptable.h>

    49 #include "../api/qscriptengine_p.h"

    50 #include "../api/qscriptable_p.h"

    51 #include "../api/qscriptcontext_p.h"

    52 #include "qscriptfunction_p.h"

    53 

    54 #include "Error.h"

    55 #include "PrototypeFunction.h"

    56 #include "PropertyNameArray.h"

    57 #include "JSFunction.h"

    58 #include "JSString.h"

    59 #include "JSValue.h"

    60 #include "JSArray.h"

    61 #include "RegExpObject.h"

    62 #include "RegExpConstructor.h"

    63 

    64 namespace JSC

    65 {

    66 QT_USE_NAMESPACE

    67 ASSERT_CLASS_FITS_IN_CELL(QScript::QObjectPrototype);

    68 ASSERT_CLASS_FITS_IN_CELL(QScript::QMetaObjectWrapperObject);

    69 ASSERT_CLASS_FITS_IN_CELL(QScript::QMetaObjectPrototype);

    70 ASSERT_CLASS_FITS_IN_CELL(QScript::QtFunction);

    71 ASSERT_CLASS_FITS_IN_CELL(QScript::QtPropertyFunction);

    72 }

    73 

    74 QT_BEGIN_NAMESPACE

    75 

    76 namespace QScript

    77 {

    78 

    79 struct QObjectConnection

    80 {

    81     int slotIndex;

    82     JSC::JSValue receiver;

    83     JSC::JSValue slot;

    84     JSC::JSValue senderWrapper;

    85 

    86     QObjectConnection(int i, JSC::JSValue r, JSC::JSValue s,

    87                       JSC::JSValue sw)

    88         : slotIndex(i), receiver(r), slot(s), senderWrapper(sw) {}

    89     QObjectConnection() : slotIndex(-1) {}

    90 

    91     bool hasTarget(JSC::JSValue r, JSC::JSValue s) const

    92     {

    93         if ((r && r.isObject()) != (receiver && receiver.isObject()))

    94             return false;

    95         if (((r && r.isObject()) && (receiver && receiver.isObject()))

    96             && (r != receiver)) {

    97             return false;

    98         }

    99         return (s == slot);

   100     }

   101 

   102     void mark(JSC::MarkStack& markStack)

   103     {

   104         // ### need to find out if senderWrapper is marked

   105         if (senderWrapper) {

   106             // see if the sender should be marked or not

   107             Q_ASSERT(senderWrapper.inherits(&QScriptObject::info));

   108             QScriptObject *scriptObject = static_cast<QScriptObject*>(JSC::asObject(senderWrapper));

   109             QScriptObjectDelegate *delegate = scriptObject->delegate();

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

   111             QObjectDelegate *inst = static_cast<QObjectDelegate*>(delegate);

   112             if ((inst->ownership() == QScriptEngine::ScriptOwnership)

   113                 || ((inst->ownership() == QScriptEngine::AutoOwnership)

   114                     && inst->value() && !inst->value()->parent())) {

   115                 // #### don't mark if not marked otherwise

   116                 //senderWrapper = JSC::JSValue();

   117                 markStack.append(senderWrapper);

   118             } else {

   119                 markStack.append(senderWrapper);

   120             }

   121         }

   122         if (receiver)

   123             markStack.append(receiver);

   124         if (slot)

   125             markStack.append(slot);

   126     }

   127 };

   128 

   129 class QObjectNotifyCaller : public QObject

   130 {

   131 public:

   132     void callConnectNotify(const char *signal)

   133         { connectNotify(signal); }

   134     void callDisconnectNotify(const char *signal)

   135         { disconnectNotify(signal); }

   136 };

   137 

   138 class QObjectConnectionManager: public QObject

   139 {

   140 public:

   141     QObjectConnectionManager(QScriptEnginePrivate *engine);

   142     ~QObjectConnectionManager();

   143 

   144     bool addSignalHandler(QObject *sender, int signalIndex,

   145                           JSC::JSValue receiver,

   146                           JSC::JSValue slot,

   147                           JSC::JSValue senderWrapper,

   148                           Qt::ConnectionType type);

   149     bool removeSignalHandler(QObject *sender, int signalIndex,

   150                              JSC::JSValue receiver,

   151                              JSC::JSValue slot);

   152 

   153     static const QMetaObject staticMetaObject;

   154     virtual const QMetaObject *metaObject() const;

   155     virtual void *qt_metacast(const char *);

   156     virtual int qt_metacall(QMetaObject::Call, int, void **argv);

   157 

   158     void execute(int slotIndex, void **argv);

   159 

   160     void mark(JSC::MarkStack&);

   161 

   162 private:

   163     QScriptEnginePrivate *engine;

   164     int slotCounter;

   165     QVector<QVector<QObjectConnection> > connections;

   166 };

   167 

   168 static bool hasMethodAccess(const QMetaMethod &method, int index, const QScriptEngine::QObjectWrapOptions &opt)

   169 {

   170     return (method.access() != QMetaMethod::Private)

   171         && ((index != 2) || !(opt & QScriptEngine::ExcludeDeleteLater));

   172 }

   173 

   174 static bool isEnumerableMetaProperty(const QMetaProperty &prop,

   175                                      const QMetaObject *mo, int index)

   176 {

   177     return prop.isScriptable() && prop.isValid()

   178         // the following lookup is to ensure that we have the

   179         // "most derived" occurrence of the property with this name

   180         && (mo->indexOfProperty(prop.name()) == index);

   181 }

   182 

   183 static inline QByteArray methodName(const QMetaMethod &method)

   184 {

   185     QByteArray signature = method.signature();

   186     return signature.left(signature.indexOf('('));

   187 }

   188 

   189 static QVariant variantFromValue(QScriptEnginePrivate *eng,

   190                                  int targetType, const QScriptValue &value)

   191 {

   192     QVariant v(targetType, (void *)0);

   193     Q_ASSERT(eng);

   194     if (QScriptEnginePrivate::convert(value, targetType, v.data(), eng))

   195         return v;

   196     if (uint(targetType) == QVariant::LastType)

   197         return value.toVariant();

   198     if (value.isVariant()) {

   199         v = value.toVariant();

   200         if (v.canConvert(QVariant::Type(targetType))) {

   201             v.convert(QVariant::Type(targetType));

   202             return v;

   203         }

   204         QByteArray typeName = v.typeName();

   205         if (typeName.endsWith('*')

   206             && (QMetaType::type(typeName.left(typeName.size()-1)) == targetType)) {

   207             return QVariant(targetType, *reinterpret_cast<void* *>(v.data()));

   208         }

   209     }

   210 

   211     return QVariant();

   212 }

   213 

   214 static const bool GeneratePropertyFunctions = true;

   215 

   216 static unsigned flagsForMetaProperty(const QMetaProperty &prop)

   217 {

   218     return (JSC::DontDelete

   219             | (!prop.isWritable() ? unsigned(JSC::ReadOnly) : unsigned(0))

   220             | (GeneratePropertyFunctions

   221                ? unsigned(JSC::Getter | JSC::Setter)

   222                   : unsigned(0))

   223             | QObjectMemberAttribute);

   224 }

   225 

   226 static int indexOfMetaEnum(const QMetaObject *meta, const QByteArray &str)

   227 {

   228     QByteArray scope;

   229     QByteArray name;

   230     int scopeIdx = str.lastIndexOf("::");

   231     if (scopeIdx != -1) {

   232         scope = str.left(scopeIdx);

   233         name = str.mid(scopeIdx + 2);

   234     } else {

   235         name = str;

   236     }

   237     for (int i = meta->enumeratorCount() - 1; i >= 0; --i) {

   238         QMetaEnum m = meta->enumerator(i);

   239         if ((m.name() == name) && (scope.isEmpty() || (m.scope() == scope)))

   240             return i;

   241     }

   242     return -1;

   243 }

   244 

   245 static inline QScriptable *scriptableFromQObject(QObject *qobj)

   246 {

   247     void *ptr = qobj->qt_metacast("QScriptable");

   248     return reinterpret_cast<QScriptable*>(ptr);

   249 }

   250 

   251 QtFunction::QtFunction(JSC::JSValue object, int initialIndex, bool maybeOverloaded,

   252                        JSC::JSGlobalData *data, WTF::PassRefPtr<JSC::Structure> sid,

   253                        const JSC::Identifier &ident)

   254     : JSC::InternalFunction(data, sid, ident),

   255       data(new Data(object, initialIndex, maybeOverloaded))

   256 {

   257 }

   258 

   259 QtFunction::~QtFunction()

   260 {

   261     delete data;

   262 }

   263 

   264 JSC::CallType QtFunction::getCallData(JSC::CallData &callData)

   265 {

   266     callData.native.function = call;

   267     return JSC::CallTypeHost;

   268 }

   269 

   270 void QtFunction::markChildren(JSC::MarkStack& markStack)

   271 {

   272     if (data->object)

   273         markStack.append(data->object);

   274     JSC::InternalFunction::markChildren(markStack);

   275 }

   276 

   277 QScriptObject *QtFunction::wrapperObject() const

   278 {

   279     Q_ASSERT(JSC::asObject(data->object)->inherits(&QScriptObject::info));

   280     return static_cast<QScriptObject*>(JSC::asObject(data->object));

   281 }

   282 

   283 QObject *QtFunction::qobject() const

   284 {

   285     QScriptObject *scriptObject = wrapperObject();

   286     QScriptObjectDelegate *delegate = scriptObject->delegate();

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

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

   289 }

   290 

   291 const QMetaObject *QtFunction::metaObject() const

   292 {

   293     QObject *qobj = qobject();

   294     if (!qobj)

   295         return 0;

   296     return qobj->metaObject();

   297 }

   298 

   299 int QtFunction::initialIndex() const

   300 {

   301     return data->initialIndex;

   302 }

   303 

   304 bool QtFunction::maybeOverloaded() const

   305 {

   306     return data->maybeOverloaded;

   307 }

   308 

   309 int QtFunction::mostGeneralMethod(QMetaMethod *out) const

   310 {

   311     const QMetaObject *meta = metaObject();

   312     if (!meta)

   313         return -1;

   314     int index = initialIndex();

   315     QMetaMethod method = meta->method(index);

   316     if (maybeOverloaded() && (method.attributes() & QMetaMethod::Cloned)) {

   317         // find the most general method

   318         do {

   319             method = meta->method(--index);

   320         } while (method.attributes() & QMetaMethod::Cloned);

   321     }

   322     if (out)

   323         *out = method;

   324     return index;

   325 }

   326 

   327 QList<int> QScript::QtFunction::overloadedIndexes() const

   328 {

   329     if (!maybeOverloaded())

   330         return QList<int>();

   331     QList<int> result;

   332     QString name = functionName();

   333     const QMetaObject *meta = metaObject();

   334     for (int index = mostGeneralMethod() - 1; index >= 0; --index) {

   335         QString otherName = QString::fromLatin1(methodName(meta->method(index)));

   336         if (otherName == name)

   337             result.append(index);

   338     }

   339     return result;

   340 }

   341 

   342 QString QtFunction::functionName() const

   343 {

   344     const QMetaObject *meta = metaObject();

   345     if (!meta)

   346         return QString();

   347     QMetaMethod method = meta->method(initialIndex());

   348     return QLatin1String(methodName(method));

   349 }

   350 

   351 class QScriptMetaType

   352 {

   353 public:

   354     enum Kind {

   355         Invalid,

   356         Variant,

   357         MetaType,

   358         Unresolved,

   359         MetaEnum

   360     };

   361 

   362     inline QScriptMetaType()

   363         : m_kind(Invalid) { }

   364 

   365     inline Kind kind() const

   366     { return m_kind; }

   367 

   368     int typeId() const;

   369 

   370     inline bool isValid() const

   371     { return (m_kind != Invalid); }

   372 

   373     inline bool isVariant() const

   374     { return (m_kind == Variant); }

   375 

   376     inline bool isMetaType() const

   377     { return (m_kind == MetaType); }

   378 

   379     inline bool isUnresolved() const

   380     { return (m_kind == Unresolved); }

   381 

   382     inline bool isMetaEnum() const

   383     { return (m_kind == MetaEnum); }

   384 

   385     QByteArray name() const;

   386 

   387     inline int enumeratorIndex() const

   388     { Q_ASSERT(isMetaEnum()); return m_typeId; }

   389 

   390     inline bool operator==(const QScriptMetaType &other) const

   391     {

   392         return (m_kind == other.m_kind) && (m_typeId == other.m_typeId);

   393     }

   394 

   395     static inline QScriptMetaType variant()

   396     { return QScriptMetaType(Variant); }

   397 

   398     static inline QScriptMetaType metaType(int typeId, const QByteArray &name)

   399     { return QScriptMetaType(MetaType, typeId, name); }

   400 

   401     static inline QScriptMetaType metaEnum(int enumIndex, const QByteArray &name)

   402     { return QScriptMetaType(MetaEnum, enumIndex, name); }

   403 

   404     static inline QScriptMetaType unresolved(const QByteArray &name)

   405     { return QScriptMetaType(Unresolved, /*typeId=*/0, name); }

   406 

   407 private:

   408     inline QScriptMetaType(Kind kind, int typeId = 0, const QByteArray &name = QByteArray())

   409         : m_kind(kind), m_typeId(typeId), m_name(name) { }

   410 

   411     Kind m_kind;

   412     int m_typeId;

   413     QByteArray m_name;

   414 };

   415 

   416 int QScriptMetaType::typeId() const

   417 {

   418     if (isVariant())

   419         return QMetaType::type("QVariant");

   420     return isMetaEnum() ? 2/*int*/ : m_typeId;

   421 }

   422 

   423 QByteArray QScriptMetaType::name() const

   424 {

   425     if (!m_name.isEmpty())

   426         return m_name;

   427     else if (m_kind == Variant)

   428         return "QVariant";

   429     return QMetaType::typeName(typeId());

   430 }

   431 

   432 class QScriptMetaMethod

   433 {

   434 public:

   435     inline QScriptMetaMethod()

   436         { }

   437     inline QScriptMetaMethod(const QByteArray &name, const QVector<QScriptMetaType> &types)

   438         : m_name(name), m_types(types), m_firstUnresolvedIndex(-1)

   439     {

   440         QVector<QScriptMetaType>::const_iterator it;

   441         for (it = m_types.constBegin(); it != m_types.constEnd(); ++it) {

   442             if ((*it).kind() == QScriptMetaType::Unresolved) {

   443                 m_firstUnresolvedIndex = it - m_types.constBegin();

   444                 break;

   445             }

   446         }

   447     }

   448     inline bool isValid() const

   449     { return !m_types.isEmpty(); }

   450 

   451     QByteArray name() const

   452     { return m_name; }

   453 

   454     inline QScriptMetaType returnType() const

   455     { return m_types.at(0); }

   456 

   457     inline int argumentCount() const

   458     { return m_types.count() - 1; }

   459 

   460     inline QScriptMetaType argumentType(int arg) const

   461     { return m_types.at(arg + 1); }

   462 

   463     inline bool fullyResolved() const

   464     { return m_firstUnresolvedIndex == -1; }

   465 

   466     inline bool hasUnresolvedReturnType() const

   467     { return (m_firstUnresolvedIndex == 0); }

   468 

   469     inline int firstUnresolvedIndex() const

   470     { return m_firstUnresolvedIndex; }

   471 

   472     inline int count() const

   473     { return m_types.count(); }

   474 

   475     inline QScriptMetaType type(int index) const

   476     { return m_types.at(index); }

   477 

   478     inline QVector<QScriptMetaType> types() const

   479     { return m_types; }

   480 

   481 private:

   482     QByteArray m_name;

   483     QVector<QScriptMetaType> m_types;

   484     int m_firstUnresolvedIndex;

   485 };

   486 

   487 struct QScriptMetaArguments

   488 {

   489     int matchDistance;

   490     int index;

   491     QScriptMetaMethod method;

   492     QVarLengthArray<QVariant, 9> args;

   493 

   494     inline QScriptMetaArguments(int dist, int idx, const QScriptMetaMethod &mtd,

   495                                 const QVarLengthArray<QVariant, 9> &as)

   496         : matchDistance(dist), index(idx), method(mtd), args(as) { }

   497     inline QScriptMetaArguments()

   498         : index(-1) { }

   499 

   500     inline bool isValid() const

   501     { return (index != -1); }

   502 };

   503 

   504 static QMetaMethod metaMethod(const QMetaObject *meta,

   505                               QMetaMethod::MethodType type,

   506                               int index)

   507 {

   508     if (type != QMetaMethod::Constructor)

   509         return meta->method(index);

   510     else

   511         return meta->constructor(index);

   512 }

   513     

   514 static JSC::JSValue callQtMethod(JSC::ExecState *exec, QMetaMethod::MethodType callType,

   515                                  QObject *thisQObject, const JSC::ArgList &scriptArgs,

   516                                  const QMetaObject *meta, int initialIndex,

   517                                  bool maybeOverloaded)

   518 {

   519     QByteArray funName;

   520     QScriptMetaMethod chosenMethod;

   521     int chosenIndex = -1;

   522     QVarLengthArray<QVariant, 9> args;

   523     QVector<QScriptMetaArguments> candidates;

   524     QVector<QScriptMetaArguments> unresolved;

   525     QVector<int> tooFewArgs;

   526     QVector<int> conversionFailed;

   527     int index;

   528     exec->clearException();

   529     QScriptEnginePrivate *engine = QScript::scriptEngineFromExec(exec);

   530     for (index = initialIndex; index >= 0; --index) {

   531         QMetaMethod method = metaMethod(meta, callType, index);

   532 

   533         if (index == initialIndex)

   534             funName = methodName(method);

   535         else {

   536             if (methodName(method) != funName)

   537                 continue;

   538         }

   539 

   540         QVector<QScriptMetaType> types;

   541         // resolve return type

   542         QByteArray returnTypeName = method.typeName();

   543         int rtype = QMetaType::type(returnTypeName);

   544         if ((rtype == 0) && !returnTypeName.isEmpty()) {

   545             if (returnTypeName == "QVariant") {

   546                 types.append(QScriptMetaType::variant());

   547             } else {

   548                 int enumIndex = indexOfMetaEnum(meta, returnTypeName);

   549                 if (enumIndex != -1)

   550                     types.append(QScriptMetaType::metaEnum(enumIndex, returnTypeName));

   551                 else

   552                     types.append(QScriptMetaType::unresolved(returnTypeName));

   553             }

   554         } else {

   555             if (callType == QMetaMethod::Constructor)

   556                 types.append(QScriptMetaType::metaType(QMetaType::QObjectStar, "QObject*"));

   557             else if (returnTypeName == "QVariant")

   558                 types.append(QScriptMetaType::variant());

   559             else

   560                 types.append(QScriptMetaType::metaType(rtype, returnTypeName));

   561         }

   562 

   563         // resolve argument types

   564         QList<QByteArray> parameterTypeNames = method.parameterTypes();

   565         for (int i = 0; i < parameterTypeNames.count(); ++i) {

   566             QByteArray argTypeName = parameterTypeNames.at(i);

   567             int atype = QMetaType::type(argTypeName);

   568             if (atype == 0) {

   569                 if (argTypeName == "QVariant") {

   570                     types.append(QScriptMetaType::variant());

   571                 } else {

   572                     int enumIndex = indexOfMetaEnum(meta, argTypeName);

   573                     if (enumIndex != -1)

   574                         types.append(QScriptMetaType::metaEnum(enumIndex, argTypeName));

   575                     else

   576                         types.append(QScriptMetaType::unresolved(argTypeName));

   577                 }

   578             } else {

   579                 if (argTypeName == "QVariant")

   580                     types.append(QScriptMetaType::variant());

   581                 else

   582                     types.append(QScriptMetaType::metaType(atype, argTypeName));

   583             }

   584         }

   585 

   586         QScriptMetaMethod mtd = QScriptMetaMethod(methodName(method), types);

   587 

   588         if (int(scriptArgs.size()) < mtd.argumentCount()) {

   589             tooFewArgs.append(index);

   590             continue;

   591         }

   592 

   593         if (!mtd.fullyResolved()) {

   594             // remember it so we can give an error message later, if necessary

   595             unresolved.append(QScriptMetaArguments(/*matchDistance=*/INT_MAX, index,

   596                                                    mtd, QVarLengthArray<QVariant, 9>()));

   597             if (mtd.hasUnresolvedReturnType())

   598                 continue;

   599         }

   600 

   601         if (args.count() != mtd.count())

   602             args.resize(mtd.count());

   603 

   604         QScriptMetaType retType = mtd.returnType();

   605         args[0] = QVariant(retType.typeId(), (void *)0); // the result

   606 

   607         // try to convert arguments

   608         bool converted = true;

   609         int matchDistance = 0;

   610         for (int i = 0; converted && i < mtd.argumentCount(); ++i) {

   611             QScriptValue actual;

   612             if (i < (int)scriptArgs.size())

   613                 actual = engine->scriptValueFromJSCValue(scriptArgs.at(i));

   614             else

   615                 actual = QScriptValue(QScriptValue::UndefinedValue);

   616             QScriptMetaType argType = mtd.argumentType(i);

   617             int tid = -1;

   618             QVariant v;

   619             if (argType.isUnresolved()) {

   620                 v = QVariant(QMetaType::QObjectStar, (void *)0);

   621                 converted = engine->convertToNativeQObject(

   622                     actual, argType.name(), reinterpret_cast<void* *>(v.data()));

   623             } else if (argType.isVariant()) {

   624                 if (actual.isVariant()) {

   625                     v = actual.toVariant();

   626                 } else {

   627                     v = actual.toVariant();

   628                     converted = v.isValid() || actual.isUndefined() || actual.isNull();

   629                 }

   630             } else {

   631                 tid = argType.typeId();

   632                 v = QVariant(tid, (void *)0);

   633                 converted = QScriptEnginePrivate::convert(actual, tid, v.data(), engine);

   634                 if (exec->hadException())

   635                     return exec->exception();

   636             }

   637 

   638             if (!converted) {

   639                 if (actual.isVariant()) {

   640                     if (tid == -1)

   641                         tid = argType.typeId();

   642                     QVariant vv = actual.toVariant();

   643                     if (vv.canConvert(QVariant::Type(tid))) {

   644                         v = vv;

   645                         converted = v.convert(QVariant::Type(tid));

   646                         if (converted && (vv.userType() != tid))

   647                             matchDistance += 10;

   648                     } else {

   649                         QByteArray vvTypeName = vv.typeName();

   650                         if (vvTypeName.endsWith('*')

   651                             && (vvTypeName.left(vvTypeName.size()-1) == argType.name())) {

   652                             v = QVariant(tid, *reinterpret_cast<void* *>(vv.data()));

   653                             converted = true;

   654                             matchDistance += 10;

   655                         }

   656                     }

   657                 } else if (actual.isNumber() || actual.isString()) {

   658                     // see if it's an enum value

   659                     QMetaEnum m;

   660                     if (argType.isMetaEnum()) {

   661                         m = meta->enumerator(argType.enumeratorIndex());

   662                     } else {

   663                         int mi = indexOfMetaEnum(meta, argType.name());

   664                         if (mi != -1)

   665                             m = meta->enumerator(mi);

   666                     }

   667                     if (m.isValid()) {

   668                         if (actual.isNumber()) {

   669                             int ival = actual.toInt32();

   670                             if (m.valueToKey(ival) != 0) {

   671                                 qVariantSetValue(v, ival);

   672                                 converted = true;

   673                                 matchDistance += 10;

   674                             }

   675                         } else {

   676                             QString sval = actual.toString();

   677                             int ival = m.keyToValue(sval.toLatin1());

   678                             if (ival != -1) {

   679                                 qVariantSetValue(v, ival);

   680                                 converted = true;

   681                                 matchDistance += 10;

   682                             }

   683                         }

   684                     }

   685                 }

   686             } else {

   687                 // determine how well the conversion matched

   688                 if (actual.isNumber()) {

   689                     switch (tid) {

   690                     case QMetaType::Double:

   691                         // perfect

   692                         break;

   693                     case QMetaType::Float:

   694                         matchDistance += 1;

   695                         break;

   696                     case QMetaType::LongLong:

   697                     case QMetaType::ULongLong:

   698                         matchDistance += 2;

   699                         break;

   700                     case QMetaType::Long:

   701                     case QMetaType::ULong:

   702                         matchDistance += 3;

   703                         break;

   704                     case QMetaType::Int:

   705                     case QMetaType::UInt:

   706                         matchDistance += 4;

   707                         break;

   708                     case QMetaType::Short:

   709                     case QMetaType::UShort:

   710                         matchDistance += 5;

   711                         break;

   712                     case QMetaType::Char:

   713                     case QMetaType::UChar:

   714                         matchDistance += 6;

   715                         break;

   716                     default:

   717                         matchDistance += 10;

   718                         break;

   719                     }

   720                 } else if (actual.isString()) {

   721                     switch (tid) {

   722                     case QMetaType::QString:

   723                         // perfect

   724                         break;

   725                     default:

   726                         matchDistance += 10;

   727                         break;

   728                     }

   729                 } else if (actual.isBoolean()) {

   730                     switch (tid) {

   731                     case QMetaType::Bool:

   732                         // perfect

   733                         break;

   734                     default:

   735                         matchDistance += 10;

   736                         break;

   737                     }

   738                 } else if (actual.isDate()) {

   739                     switch (tid) {

   740                     case QMetaType::QDateTime:

   741                         // perfect

   742                         break;

   743                     case QMetaType::QDate:

   744                         matchDistance += 1;

   745                         break;

   746                     case QMetaType::QTime:

   747                         matchDistance += 2;

   748                         break;

   749                     default:

   750                         matchDistance += 10;

   751                         break;

   752                     }

   753                 } else if (actual.isRegExp()) {

   754                     switch (tid) {

   755                     case QMetaType::QRegExp:

   756                         // perfect

   757                         break;

   758                     default:

   759                         matchDistance += 10;

   760                         break;

   761                     }

   762                 } else if (actual.isVariant()) {

   763                     if (argType.isVariant()

   764                         || (actual.toVariant().userType() == tid)) {

   765                         // perfect

   766                     } else {

   767                         matchDistance += 10;

   768                     }

   769                 } else if (actual.isArray()) {

   770                     switch (tid) {

   771                     case QMetaType::QStringList:

   772                     case QMetaType::QVariantList:

   773                         matchDistance += 5;

   774                         break;

   775                     default:

   776                         matchDistance += 10;

   777                         break;

   778                     }

   779                 } else if (actual.isQObject()) {

   780                     switch (tid) {

   781                     case QMetaType::QObjectStar:

   782                     case QMetaType::QWidgetStar:

   783                         // perfect

   784                         break;

   785                     default:

   786                         matchDistance += 10;

   787                         break;

   788                     }

   789                 } else if (actual.isNull()) {

   790                     switch (tid) {

   791                     case QMetaType::VoidStar:

   792                     case QMetaType::QObjectStar:

   793                     case QMetaType::QWidgetStar:

   794                         // perfect

   795                         break;

   796                     default:

   797                         if (!argType.name().endsWith('*'))

   798                             matchDistance += 10;

   799                         break;

   800                     }

   801                 } else {

   802                     matchDistance += 10;

   803                 }

   804             }

   805 

   806             if (converted)

   807                 args[i+1] = v;

   808         }

   809 

   810         if (converted) {

   811             if ((scriptArgs.size() == (size_t)mtd.argumentCount())

   812                 && (matchDistance == 0)) {

   813                 // perfect match, use this one

   814                 chosenMethod = mtd;

   815                 chosenIndex = index;

   816                 break;

   817             } else {

   818                 bool redundant = false;

   819                 if ((callType != QMetaMethod::Constructor)

   820                     && (index < meta->methodOffset())) {

   821                     // it is possible that a virtual method is redeclared in a subclass,

   822                     // in which case we want to ignore the superclass declaration

   823                     for (int i = 0; i < candidates.size(); ++i) {

   824                         const QScriptMetaArguments &other = candidates.at(i);

   825                         if (mtd.types() == other.method.types()) {

   826                             redundant = true;

   827                             break;

   828                         }

   829                     }

   830                 }

   831                 if (!redundant) {

   832                     QScriptMetaArguments metaArgs(matchDistance, index, mtd, args);

   833                     if (candidates.isEmpty()) {

   834                         candidates.append(metaArgs);

   835                     } else {

   836                         const QScriptMetaArguments &otherArgs = candidates.at(0);

   837                         if ((args.count() > otherArgs.args.count())

   838                             || ((args.count() == otherArgs.args.count())

   839                                 && (matchDistance <= otherArgs.matchDistance))) {

   840                             candidates.prepend(metaArgs);

   841                         } else {

   842                             candidates.append(metaArgs);

   843                         }

   844                     }

   845                 }

   846             }

   847         } else if (mtd.fullyResolved()) {

   848             conversionFailed.append(index);

   849         }

   850 

   851         if (!maybeOverloaded)

   852             break;

   853     }

   854 

   855     JSC::JSValue result;

   856     if ((chosenIndex == -1) && candidates.isEmpty()) {

   857 //        context->calleeMetaIndex = initialIndex;

   858 //#ifndef Q_SCRIPT_NO_EVENT_NOTIFY

   859 //        engine->notifyFunctionEntry(context);

   860 //#endif

   861         if (!conversionFailed.isEmpty()) {

   862             QString message = QString::fromLatin1("incompatible type of argument(s) in call to %0(); candidates were\n")

   863                               .arg(QLatin1String(funName));

   864             for (int i = 0; i < conversionFailed.size(); ++i) {

   865                 if (i > 0)

   866                     message += QLatin1String("\n");

   867                 QMetaMethod mtd = metaMethod(meta, callType, conversionFailed.at(i));

   868                 message += QString::fromLatin1("    %0").arg(QString::fromLatin1(mtd.signature()));

   869             }

   870             result = JSC::throwError(exec, JSC::TypeError, message);

   871         } else if (!unresolved.isEmpty()) {

   872             QScriptMetaArguments argsInstance = unresolved.first();

   873             int unresolvedIndex = argsInstance.method.firstUnresolvedIndex();

   874             Q_ASSERT(unresolvedIndex != -1);

   875             QScriptMetaType unresolvedType = argsInstance.method.type(unresolvedIndex);

   876             QString unresolvedTypeName = QString::fromLatin1(unresolvedType.name());

   877             QString message = QString::fromLatin1("cannot call %0(): ")

   878                               .arg(QString::fromLatin1(funName));

   879             if (unresolvedIndex > 0) {

   880                 message.append(QString::fromLatin1("argument %0 has unknown type `%1'").

   881                                arg(unresolvedIndex).arg(unresolvedTypeName));

   882             } else {

   883                 message.append(QString::fromLatin1("unknown return type `%0'")

   884                                .arg(unresolvedTypeName));

   885             }

   886             message.append(QString::fromLatin1(" (register the type with qScriptRegisterMetaType())"));

   887             result = JSC::throwError(exec, JSC::TypeError, message);

   888         } else {

   889             QString message = QString::fromLatin1("too few arguments in call to %0(); candidates are\n")

   890                               .arg(QLatin1String(funName));

   891             for (int i = 0; i < tooFewArgs.size(); ++i) {

   892                 if (i > 0)

   893                     message += QLatin1String("\n");

   894                 QMetaMethod mtd = metaMethod(meta, callType, tooFewArgs.at(i));

   895                 message += QString::fromLatin1("    %0").arg(QString::fromLatin1(mtd.signature()));

   896             }

   897             result = JSC::throwError(exec, JSC::SyntaxError, message);

   898         }

   899     } else {

   900         if (chosenIndex == -1) {

   901             QScriptMetaArguments metaArgs = candidates.at(0);

   902             if ((candidates.size() > 1)

   903                 && (metaArgs.args.count() == candidates.at(1).args.count())

   904                 && (metaArgs.matchDistance == candidates.at(1).matchDistance)) {

   905                 // ambiguous call

   906                 QString message = QString::fromLatin1("ambiguous call of overloaded function %0(); candidates were\n")

   907                                   .arg(QLatin1String(funName));

   908                 for (int i = 0; i < candidates.size(); ++i) {

   909                     if (i > 0)

   910                         message += QLatin1String("\n");

   911                     QMetaMethod mtd = metaMethod(meta, callType, candidates.at(i).index);

   912                     message += QString::fromLatin1("    %0").arg(QString::fromLatin1(mtd.signature()));

   913                 }

   914                 result = JSC::throwError(exec, JSC::TypeError, message);

   915             } else {

   916                 chosenMethod = metaArgs.method;

   917                 chosenIndex = metaArgs.index;

   918                 args = metaArgs.args;

   919             }

   920         }

   921 

   922         if (chosenIndex != -1) {

   923             // call it

   924 //            context->calleeMetaIndex = chosenIndex;

   925 

   926             QVarLengthArray<void*, 9> array(args.count());

   927             void **params = array.data();

   928             for (int i = 0; i < args.count(); ++i) {

   929                 const QVariant &v = args[i];

   930                 switch (chosenMethod.type(i).kind()) {

   931                 case QScriptMetaType::Variant:

   932                     params[i] = const_cast<QVariant*>(&v);

   933                     break;

   934                 case QScriptMetaType::MetaType:

   935                 case QScriptMetaType::MetaEnum:

   936                 case QScriptMetaType::Unresolved:

   937                     params[i] = const_cast<void*>(v.constData());

   938                     break;

   939                 default:

   940                     Q_ASSERT(0);

   941                 }

   942             }

   943 

   944             QScriptable *scriptable = 0;

   945             if (thisQObject)

   946                 scriptable = scriptableFromQObject(thisQObject);

   947             QScriptEngine *oldEngine = 0;

   948             if (scriptable) {

   949                 oldEngine = QScriptablePrivate::get(scriptable)->engine;

   950                 QScriptablePrivate::get(scriptable)->engine = QScriptEnginePrivate::get(engine);

   951             }

   952 

   953 // ### fixme

   954 //#ifndef Q_SCRIPT_NO_EVENT_NOTIFY

   955 //            engine->notifyFunctionEntry(context);

   956 //#endif

   957 

   958             if (callType == QMetaMethod::Constructor) {

   959                 Q_ASSERT(meta != 0);

   960                 meta->static_metacall(QMetaObject::CreateInstance, chosenIndex, params);

   961             } else {

   962                 QMetaObject::metacall(thisQObject, QMetaObject::InvokeMetaMethod, chosenIndex, params);

   963             }

   964 

   965             if (scriptable)

   966                 QScriptablePrivate::get(scriptable)->engine = oldEngine;

   967 

   968             if (exec->hadException()) {

   969                 result = exec->exception() ; // propagate

   970             } else {

   971                 QScriptMetaType retType = chosenMethod.returnType();

   972                 if (retType.isVariant()) {

   973                     result = engine->jscValueFromVariant(*(QVariant *)params[0]);

   974                 } else if (retType.typeId() != 0) {

   975                     result = engine->scriptValueToJSCValue(engine->create(retType.typeId(), params[0]));

   976                     if (!result) {

   977                         QScriptValue sv = QScriptEnginePrivate::get(engine)->newVariant(QVariant(retType.typeId(), params[0]));

   978                         result = engine->scriptValueToJSCValue(sv);

   979                     }

   980                 } else {

   981                     result = JSC::jsUndefined();

   982                 }

   983             }

   984         }

   985     }

   986 

   987     return result;

   988 }

   989 

   990 JSC::JSValue QtFunction::execute(JSC::ExecState *exec, JSC::JSValue thisValue,

   991                                  const JSC::ArgList &scriptArgs)

   992 {

   993     Q_ASSERT(data->object.inherits(&QScriptObject::info));

   994     QScriptObject *scriptObject = static_cast<QScriptObject*>(JSC::asObject(data->object));

   995     QScriptObjectDelegate *delegate = scriptObject->delegate();

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

   997     QObject *qobj = static_cast<QScript::QObjectDelegate*>(delegate)->value();

   998     Q_ASSERT_X(qobj != 0, "QtFunction::call", "handle the case when QObject has been deleted");

   999     QScriptEnginePrivate *engine = scriptEngineFromExec(exec);

  1000 

  1001     const QMetaObject *meta = qobj->metaObject();

  1002     QObject *thisQObject = 0;

  1003     thisValue = engine->toUsableValue(thisValue);

  1004     if (thisValue.inherits(&QScriptObject::info)) {

  1005         delegate = static_cast<QScriptObject*>(JSC::asObject(thisValue))->delegate();

  1006         if (delegate && (delegate->type() == QScriptObjectDelegate::QtObject))

  1007             thisQObject = static_cast<QScript::QObjectDelegate*>(delegate)->value();

  1008     }

  1009     if (!thisQObject)

  1010         thisQObject = qobj; // ### TypeError

  1011 

  1012     if (!meta->cast(thisQObject)) {

  1013         // invoking a function in the prototype

  1014         thisQObject = qobj;

  1015     }

  1016 

  1017     return callQtMethod(exec, QMetaMethod::Method, thisQObject, scriptArgs,

  1018                         meta, data->initialIndex, data->maybeOverloaded);

  1019 }

  1020 

  1021 const JSC::ClassInfo QtFunction::info = { "QtFunction", &InternalFunction::info, 0, 0 };

  1022 

  1023 JSC::JSValue JSC_HOST_CALL QtFunction::call(JSC::ExecState *exec, JSC::JSObject *callee,

  1024                                             JSC::JSValue thisValue, const JSC::ArgList &args)

  1025 {

  1026     if (!callee->inherits(&QtFunction::info))

  1027         return throwError(exec, JSC::TypeError, "callee is not a QtFunction object");

  1028     QtFunction *qfun =  static_cast<QtFunction*>(callee);

  1029     QScriptEnginePrivate *eng_p = scriptEngineFromExec(exec);

  1030     JSC::ExecState *previousFrame = eng_p->currentFrame;

  1031     eng_p->currentFrame = exec;

  1032     eng_p->pushContext(exec, thisValue, args, callee);

  1033     JSC::JSValue result = qfun->execute(eng_p->currentFrame, thisValue, args);

  1034     eng_p->popContext();

  1035     eng_p->currentFrame = previousFrame;

  1036     return result;

  1037 }

  1038 

  1039 const JSC::ClassInfo QtPropertyFunction::info = { "QtPropertyFunction", &InternalFunction::info, 0, 0 };

  1040 

  1041 QtPropertyFunction::QtPropertyFunction(const QMetaObject *meta, int index,

  1042                                        JSC::JSGlobalData *data,

  1043                                        WTF::PassRefPtr<JSC::Structure> sid,

  1044                                        const JSC::Identifier &ident)

  1045     : JSC::InternalFunction(data, sid, ident),

  1046       data(new Data(meta, index))

  1047 {

  1048 }

  1049 

  1050 QtPropertyFunction::~QtPropertyFunction()

  1051 {

  1052     delete data;

  1053 }

  1054 

  1055 JSC::CallType QtPropertyFunction::getCallData(JSC::CallData &callData)

  1056 {

  1057     callData.native.function = call;

  1058     return JSC::CallTypeHost;

  1059 }

  1060 

  1061 JSC::JSValue JSC_HOST_CALL QtPropertyFunction::call(

  1062     JSC::ExecState *exec, JSC::JSObject *callee,

  1063     JSC::JSValue thisValue, const JSC::ArgList &args)

  1064 {

  1065     if (!callee->inherits(&QtPropertyFunction::info))

  1066         return throwError(exec, JSC::TypeError, "callee is not a QtPropertyFunction object");

  1067     QtPropertyFunction *qfun =  static_cast<QtPropertyFunction*>(callee);

  1068     QScriptEnginePrivate *eng_p = scriptEngineFromExec(exec);

  1069     JSC::ExecState *previousFrame = eng_p->currentFrame;

  1070     eng_p->currentFrame = exec;

  1071     eng_p->pushContext(exec, thisValue, args, callee);

  1072     JSC::JSValue result = qfun->execute(eng_p->currentFrame, thisValue, args);

  1073     eng_p->popContext();

  1074     eng_p->currentFrame = previousFrame;

  1075     return result;

  1076 }

  1077 

  1078 JSC::JSValue QtPropertyFunction::execute(JSC::ExecState *exec,

  1079                                          JSC::JSValue thisValue,

  1080                                          const JSC::ArgList &args)

  1081 {

  1082     JSC::JSValue result = JSC::jsUndefined();

  1083 

  1084     // ### don't go via QScriptValue

  1085     QScriptEnginePrivate *engine = scriptEngineFromExec(exec);

  1086     thisValue = engine->toUsableValue(thisValue);

  1087     QScriptValue object = engine->scriptValueFromJSCValue(thisValue);

  1088     QObject *qobject = object.toQObject();

  1089     while ((!qobject || (qobject->metaObject() != data->meta))

  1090            && object.prototype().isObject()) {

  1091         object = object.prototype();

  1092         qobject = object.toQObject();

  1093     }

  1094     Q_ASSERT_X(qobject, Q_FUNC_INFO, "this-object must be a QObject");

  1095 

  1096     QMetaProperty prop = data->meta->property(data->index);

  1097     Q_ASSERT(prop.isScriptable());

  1098     if (args.size() == 0) {

  1099         // get

  1100         if (prop.isValid()) {

  1101             QScriptable *scriptable = scriptableFromQObject(qobject);

  1102             QScriptEngine *oldEngine = 0;

  1103             if (scriptable) {

  1104                 oldEngine = QScriptablePrivate::get(scriptable)->engine;

  1105                 QScriptablePrivate::get(scriptable)->engine = QScriptEnginePrivate::get(engine);

  1106             }

  1107 

  1108             QVariant v = prop.read(qobject);

  1109 

  1110             if (scriptable)

  1111                 QScriptablePrivate::get(scriptable)->engine = oldEngine;

  1112 

  1113             result = engine->jscValueFromVariant(v);

  1114         }

  1115     } else {

  1116         // set

  1117         JSC::JSValue arg = args.at(0);

  1118         QVariant v;

  1119         if (prop.isEnumType() && arg.isString()

  1120             && !engine->hasDemarshalFunction(prop.userType())) {

  1121             // give QMetaProperty::write() a chance to convert from

  1122             // string to enum value

  1123             v = (QString)arg.toString(exec);

  1124         } else {

  1125             // ### don't go via QScriptValue

  1126             QScriptValue tmp = engine->scriptValueFromJSCValue(arg);

  1127             v = variantFromValue(engine, prop.userType(), tmp);

  1128         }

  1129 

  1130         QScriptable *scriptable = scriptableFromQObject(qobject);

  1131         QScriptEngine *oldEngine = 0;

  1132         if (scriptable) {

  1133             oldEngine = QScriptablePrivate::get(scriptable)->engine;

  1134             QScriptablePrivate::get(scriptable)->engine = QScriptEnginePrivate::get(engine);