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 "qscriptqobject_p.h"

    26 

    27 #include <QtCore/qmetaobject.h>

    28 #include <QtCore/qvarlengtharray.h>

    29 #include <QtCore/qdebug.h>

    30 #include <QtScript/qscriptable.h>

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

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

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

    34 #include "qscriptfunction_p.h"

    35 

    36 #include "Error.h"

    37 #include "PrototypeFunction.h"

    38 #include "PropertyNameArray.h"

    39 #include "JSFunction.h"

    40 #include "JSString.h"

    41 #include "JSValue.h"

    42 #include "JSArray.h"

    43 #include "RegExpObject.h"

    44 #include "RegExpConstructor.h"

    45 

    46 namespace JSC

    47 {

    48 QT_USE_NAMESPACE

    49 ASSERT_CLASS_FITS_IN_CELL(QScript::QObjectPrototype);

    50 ASSERT_CLASS_FITS_IN_CELL(QScript::QMetaObjectWrapperObject);

    51 ASSERT_CLASS_FITS_IN_CELL(QScript::QMetaObjectPrototype);

    52 ASSERT_CLASS_FITS_IN_CELL(QScript::QtFunction);

    53 ASSERT_CLASS_FITS_IN_CELL(QScript::QtPropertyFunction);

    54 }

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 namespace QScript

    59 {

    60 

    61 struct QObjectConnection

    62 {

    63     int slotIndex;

    64     JSC::JSValue receiver;

    65     JSC::JSValue slot;

    66     JSC::JSValue senderWrapper;

    67 

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

    69                       JSC::JSValue sw)

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

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

    72 

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

    74     {

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

    76             return false;

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

    78             && (r != receiver)) {

    79             return false;

    80         }

    81         return (s == slot);

    82     }

    83 

    84     void mark(JSC::MarkStack& markStack)

    85     {

    86         if (senderWrapper) {

    87             // see if the sender should be marked or not;

    88             // if the C++ object is owned by script, we don't want

    89             // it to stay alive due to a script connection.

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

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

    92             if (!JSC::Heap::isCellMarked(scriptObject)) {

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

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

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

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

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

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

    99                     senderWrapper = JSC::JSValue();

   100                 } else {

   101                     markStack.append(senderWrapper);

   102                 }

   103             }

   104         }

   105         if (receiver)

   106             markStack.append(receiver);

   107         if (slot)

   108             markStack.append(slot);

   109     }

   110 };

   111 

   112 class QObjectNotifyCaller : public QObject

   113 {

   114 public:

   115     void callConnectNotify(const char *signal)

   116         { connectNotify(signal); }

   117     void callDisconnectNotify(const char *signal)

   118         { disconnectNotify(signal); }

   119 };

   120 

   121 class QObjectConnectionManager: public QObject

   122 {

   123 public:

   124     QObjectConnectionManager(QScriptEnginePrivate *engine);

   125     ~QObjectConnectionManager();

   126 

   127     bool addSignalHandler(QObject *sender, int signalIndex,

   128                           JSC::JSValue receiver,

   129                           JSC::JSValue slot,

   130                           JSC::JSValue senderWrapper,

   131                           Qt::ConnectionType type);

   132     bool removeSignalHandler(QObject *sender, int signalIndex,

   133                              JSC::JSValue receiver,

   134                              JSC::JSValue slot);

   135 

   136     static const QMetaObject staticMetaObject;

   137     virtual const QMetaObject *metaObject() const;

   138     virtual void *qt_metacast(const char *);

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

   140 

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

   142 

   143     void mark(JSC::MarkStack&);

   144 

   145 private:

   146     QScriptEnginePrivate *engine;

   147     int slotCounter;

   148     QVector<QVector<QObjectConnection> > connections;

   149 };

   150 

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

   152 {

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

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

   155 }

   156 

   157 static bool isEnumerableMetaProperty(const QMetaProperty &prop,

   158                                      const QMetaObject *mo, int index)

   159 {

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

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

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

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

   164 }

   165 

   166 static inline QByteArray methodName(const QMetaMethod &method)

   167 {

   168     QByteArray signature = method.signature();

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

   170 }

   171 

   172 static QVariant variantFromValue(QScriptEnginePrivate *eng,

   173                                  int targetType, const QScriptValue &value)

   174 {

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

   176     Q_ASSERT(eng);

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

   178         return v;

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

   180         return value.toVariant();

   181     if (value.isVariant()) {

   182         v = value.toVariant();

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

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

   185             return v;

   186         }

   187         QByteArray typeName = v.typeName();

   188         if (typeName.endsWith('*')

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

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

   191         }

   192     }

   193 

   194     return QVariant();

   195 }

   196 

   197 static const bool GeneratePropertyFunctions = true;

   198 

   199 static unsigned flagsForMetaProperty(const QMetaProperty &prop)

   200 {

   201     return (JSC::DontDelete

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

   203             | (GeneratePropertyFunctions

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

   205                   : unsigned(0))

   206             | QObjectMemberAttribute);

   207 }

   208 

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

   210 {

   211     QByteArray scope;

   212     QByteArray name;

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

   214     if (scopeIdx != -1) {

   215         scope = str.left(scopeIdx);

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

   217     } else {

   218         name = str;

   219     }

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

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

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

   223             return i;

   224     }

   225     return -1;

   226 }

   227 

   228 static inline QScriptable *scriptableFromQObject(QObject *qobj)

   229 {

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

   231     return reinterpret_cast<QScriptable*>(ptr);

   232 }

   233 

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

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

   236                        const JSC::Identifier &ident)

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

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

   239 {

   240 }

   241 

   242 QtFunction::~QtFunction()

   243 {

   244     delete data;

   245 }

   246 

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

   248 {

   249     callData.native.function = call;

   250     return JSC::CallTypeHost;

   251 }

   252 

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

   254 {

   255     if (data->object)

   256         markStack.append(data->object);

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

   258 }

   259 

   260 QScriptObject *QtFunction::wrapperObject() const

   261 {

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

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

   264 }

   265 

   266 QObject *QtFunction::qobject() const

   267 {

   268     QScriptObject *scriptObject = wrapperObject();

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

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

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

   272 }

   273 

   274 const QMetaObject *QtFunction::metaObject() const

   275 {

   276     QObject *qobj = qobject();

   277     if (!qobj)

   278         return 0;

   279     return qobj->metaObject();

   280 }

   281 

   282 int QtFunction::initialIndex() const

   283 {

   284     return data->initialIndex;

   285 }

   286 

   287 bool QtFunction::maybeOverloaded() const

   288 {

   289     return data->maybeOverloaded;

   290 }

   291 

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

   293 {

   294     const QMetaObject *meta = metaObject();

   295     if (!meta)

   296         return -1;

   297     int index = initialIndex();

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

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

   300         // find the most general method

   301         do {

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

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

   304     }

   305     if (out)

   306         *out = method;

   307     return index;

   308 }

   309 

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

   311 {

   312     if (!maybeOverloaded())

   313         return QList<int>();

   314     QList<int> result;

   315     QString name = functionName();

   316     const QMetaObject *meta = metaObject();

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

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

   319         if (otherName == name)

   320             result.append(index);

   321     }

   322     return result;

   323 }

   324 

   325 QString QtFunction::functionName() const

   326 {

   327     const QMetaObject *meta = metaObject();

   328     if (!meta)

   329         return QString();

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

   331     return QLatin1String(methodName(method));

   332 }

   333 

   334 class QScriptMetaType

   335 {

   336 public:

   337     enum Kind {

   338         Invalid,

   339         Variant,

   340         MetaType,

   341         Unresolved,

   342         MetaEnum

   343     };

   344 

   345     inline QScriptMetaType()

   346         : m_kind(Invalid) { }

   347 

   348     inline Kind kind() const

   349     { return m_kind; }

   350 

   351     int typeId() const;

   352 

   353     inline bool isValid() const

   354     { return (m_kind != Invalid); }

   355 

   356     inline bool isVariant() const

   357     { return (m_kind == Variant); }

   358 

   359     inline bool isMetaType() const

   360     { return (m_kind == MetaType); }

   361 

   362     inline bool isUnresolved() const

   363     { return (m_kind == Unresolved); }

   364 

   365     inline bool isMetaEnum() const

   366     { return (m_kind == MetaEnum); }

   367 

   368     QByteArray name() const;

   369 

   370     inline int enumeratorIndex() const

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

   372 

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

   374     {

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

   376     }

   377 

   378     static inline QScriptMetaType variant()

   379     { return QScriptMetaType(Variant); }

   380 

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

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

   383 

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

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

   386 

   387     static inline QScriptMetaType unresolved(const QByteArray &name)

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

   389 

   390 private:

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

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

   393 

   394     Kind m_kind;

   395     int m_typeId;

   396     QByteArray m_name;

   397 };

   398 

   399 int QScriptMetaType::typeId() const

   400 {

   401     if (isVariant())

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

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

   404 }

   405 

   406 QByteArray QScriptMetaType::name() const

   407 {

   408     if (!m_name.isEmpty())

   409         return m_name;

   410     else if (m_kind == Variant)

   411         return "QVariant";

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

   413 }

   414 

   415 class QScriptMetaMethod

   416 {

   417 public:

   418     inline QScriptMetaMethod()

   419         { }

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

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

   422     {

   423         QVector<QScriptMetaType>::const_iterator it;

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

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

   426                 m_firstUnresolvedIndex = it - m_types.constBegin();

   427                 break;

   428             }

   429         }

   430     }

   431     inline bool isValid() const

   432     { return !m_types.isEmpty(); }

   433 

   434     QByteArray name() const

   435     { return m_name; }

   436 

   437     inline QScriptMetaType returnType() const

   438     { return m_types.at(0); }

   439 

   440     inline int argumentCount() const

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

   442 

   443     inline QScriptMetaType argumentType(int arg) const

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

   445 

   446     inline bool fullyResolved() const

   447     { return m_firstUnresolvedIndex == -1; }

   448 

   449     inline bool hasUnresolvedReturnType() const

   450     { return (m_firstUnresolvedIndex == 0); }

   451 

   452     inline int firstUnresolvedIndex() const

   453     { return m_firstUnresolvedIndex; }

   454 

   455     inline int count() const

   456     { return m_types.count(); }

   457 

   458     inline QScriptMetaType type(int index) const

   459     { return m_types.at(index); }

   460 

   461     inline QVector<QScriptMetaType> types() const

   462     { return m_types; }

   463 

   464 private:

   465     QByteArray m_name;

   466     QVector<QScriptMetaType> m_types;

   467     int m_firstUnresolvedIndex;

   468 };

   469 

   470 struct QScriptMetaArguments

   471 {

   472     int matchDistance;

   473     int index;

   474     QScriptMetaMethod method;

   475     QVarLengthArray<QVariant, 9> args;

   476 

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

   478                                 const QVarLengthArray<QVariant, 9> &as)

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

   480     inline QScriptMetaArguments()

   481         : index(-1) { }

   482 

   483     inline bool isValid() const

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

   485 };

   486 

   487 static QMetaMethod metaMethod(const QMetaObject *meta,

   488                               QMetaMethod::MethodType type,

   489                               int index)

   490 {

   491     if (type != QMetaMethod::Constructor)

   492         return meta->method(index);

   493     else

   494         return meta->constructor(index);

   495 }

   496     

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

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

   499                                  const QMetaObject *meta, int initialIndex,

   500                                  bool maybeOverloaded)

   501 {

   502     QByteArray funName;

   503     QScriptMetaMethod chosenMethod;

   504     int chosenIndex = -1;

   505     QVarLengthArray<QVariant, 9> args;

   506     QVector<QScriptMetaArguments> candidates;

   507     QVector<QScriptMetaArguments> unresolved;

   508     QVector<int> tooFewArgs;

   509     QVector<int> conversionFailed;

   510     int index;

   511     exec->clearException();

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

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

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

   515 

   516         if (index == initialIndex)

   517             funName = methodName(method);

   518         else {

   519             if (methodName(method) != funName)

   520                 continue;

   521         }

   522 

   523         QVector<QScriptMetaType> types;

   524         // resolve return type

   525         QByteArray returnTypeName = method.typeName();

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

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

   528             if (returnTypeName == "QVariant") {

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

   530             } else {

   531                 int enumIndex = indexOfMetaEnum(meta, returnTypeName);

   532                 if (enumIndex != -1)

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

   534                 else

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

   536             }

   537         } else {

   538             if (callType == QMetaMethod::Constructor)

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

   540             else if (returnTypeName == "QVariant")

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

   542             else

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

   544         }

   545 

   546         // resolve argument types

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

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

   549             QByteArray argTypeName = parameterTypeNames.at(i);

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

   551             if (atype == 0) {

   552                 if (argTypeName == "QVariant") {

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

   554                 } else {

   555                     int enumIndex = indexOfMetaEnum(meta, argTypeName);

   556                     if (enumIndex != -1)

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

   558                     else

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

   560                 }

   561             } else {

   562                 if (argTypeName == "QVariant")

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

   564                 else

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

   566             }

   567         }

   568 

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

   570 

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

   572             tooFewArgs.append(index);

   573             continue;

   574         }

   575 

   576         if (!mtd.fullyResolved()) {

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

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

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

   580             if (mtd.hasUnresolvedReturnType())

   581                 continue;

   582         }

   583 

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

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

   586 

   587         QScriptMetaType retType = mtd.returnType();

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

   589 

   590         // try to convert arguments

   591         bool converted = true;

   592         int matchDistance = 0;

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

   594             QScriptValue actual;

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

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

   597             else

   598                 actual = QScriptValue(QScriptValue::UndefinedValue);

   599             QScriptMetaType argType = mtd.argumentType(i);

   600             int tid = -1;

   601             QVariant v;

   602             if (argType.isUnresolved()) {

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

   604                 converted = engine->convertToNativeQObject(

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

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

   607                 if (actual.isVariant()) {

   608                     v = actual.toVariant();

   609                 } else {

   610                     v = actual.toVariant();

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

   612                 }

   613             } else {

   614                 tid = argType.typeId();

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

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

   617                 if (exec->hadException())

   618                     return exec->exception();

   619             }

   620 

   621             if (!converted) {

   622                 if (actual.isVariant()) {

   623                     if (tid == -1)

   624                         tid = argType.typeId();

   625                     QVariant vv = actual.toVariant();

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

   627                         v = vv;

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

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

   630                             matchDistance += 10;

   631                     } else {

   632                         QByteArray vvTypeName = vv.typeName();

   633                         if (vvTypeName.endsWith('*')

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

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

   636                             converted = true;

   637                             matchDistance += 10;

   638                         }

   639                     }

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

   641                     // see if it's an enum value

   642                     QMetaEnum m;

   643                     if (argType.isMetaEnum()) {

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

   645                     } else {

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

   647                         if (mi != -1)

   648                             m = meta->enumerator(mi);

   649                     }

   650                     if (m.isValid()) {

   651                         if (actual.isNumber()) {

   652                             int ival = actual.toInt32();

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

   654                                 qVariantSetValue(v, ival);

   655                                 converted = true;

   656                                 matchDistance += 10;

   657                             }

   658                         } else {

   659                             QString sval = actual.toString();

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

   661                             if (ival != -1) {

   662                                 qVariantSetValue(v, ival);

   663                                 converted = true;

   664                                 matchDistance += 10;

   665                             }

   666                         }

   667                     }

   668                 }

   669             } else {

   670                 // determine how well the conversion matched

   671                 if (actual.isNumber()) {

   672                     switch (tid) {

   673                     case QMetaType::Double:

   674                         // perfect

   675                         break;

   676                     case QMetaType::Float:

   677                         matchDistance += 1;

   678                         break;

   679                     case QMetaType::LongLong:

   680                     case QMetaType::ULongLong:

   681                         matchDistance += 2;

   682                         break;

   683                     case QMetaType::Long:

   684                     case QMetaType::ULong:

   685                         matchDistance += 3;

   686                         break;

   687                     case QMetaType::Int:

   688                     case QMetaType::UInt:

   689                         matchDistance += 4;

   690                         break;

   691                     case QMetaType::Short:

   692                     case QMetaType::UShort:

   693                         matchDistance += 5;

   694                         break;

   695                     case QMetaType::Char:

   696                     case QMetaType::UChar:

   697                         matchDistance += 6;

   698                         break;

   699                     default:

   700                         matchDistance += 10;

   701                         break;

   702                     }

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

   704                     switch (tid) {

   705                     case QMetaType::QString:

   706                         // perfect

   707                         break;

   708                     default:

   709                         matchDistance += 10;

   710                         break;

   711                     }

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

   713                     switch (tid) {

   714                     case QMetaType::Bool:

   715                         // perfect

   716                         break;

   717                     default:

   718                         matchDistance += 10;

   719                         break;

   720                     }

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

   722                     switch (tid) {

   723                     case QMetaType::QDateTime:

   724                         // perfect

   725                         break;

   726                     case QMetaType::QDate:

   727                         matchDistance += 1;

   728                         break;

   729                     case QMetaType::QTime:

   730                         matchDistance += 2;

   731                         break;

   732                     default:

   733                         matchDistance += 10;

   734                         break;

   735                     }

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

   737                     switch (tid) {

   738                     case QMetaType::QRegExp:

   739                         // perfect

   740                         break;

   741                     default:

   742                         matchDistance += 10;

   743                         break;

   744                     }

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

   746                     if (argType.isVariant()

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

   748                         // perfect

   749                     } else {

   750                         matchDistance += 10;

   751                     }

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

   753                     switch (tid) {

   754                     case QMetaType::QStringList:

   755                     case QMetaType::QVariantList:

   756                         matchDistance += 5;

   757                         break;

   758                     default:

   759                         matchDistance += 10;

   760                         break;

   761                     }

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

   763                     switch (tid) {

   764                     case QMetaType::QObjectStar:

   765                     case QMetaType::QWidgetStar:

   766                         // perfect

   767                         break;

   768                     default:

   769                         matchDistance += 10;

   770                         break;

   771                     }

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

   773                     switch (tid) {

   774                     case QMetaType::VoidStar:

   775                     case QMetaType::QObjectStar:

   776                     case QMetaType::QWidgetStar:

   777                         // perfect

   778                         break;

   779                     default:

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

   781                             matchDistance += 10;

   782                         break;

   783                     }

   784                 } else {

   785                     matchDistance += 10;

   786                 }

   787             }

   788 

   789             if (converted)

   790                 args[i+1] = v;

   791         }

   792 

   793         if (converted) {

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

   795                 && (matchDistance == 0)) {

   796                 // perfect match, use this one

   797                 chosenMethod = mtd;

   798                 chosenIndex = index;

   799                 break;

   800             } else {

   801                 bool redundant = false;

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

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

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

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

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

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

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

   809                             redundant = true;

   810                             break;

   811                         }

   812                     }

   813                 }

   814                 if (!redundant) {

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

   816                     if (candidates.isEmpty()) {

   817                         candidates.append(metaArgs);

   818                     } else {

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

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

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

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

   823                             candidates.prepend(metaArgs);

   824                         } else {

   825                             candidates.append(metaArgs);

   826                         }

   827                     }

   828                 }

   829             }

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

   831             conversionFailed.append(index);

   832         }

   833 

   834         if (!maybeOverloaded)

   835             break;

   836     }

   837 

   838     JSC::JSValue result;

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

   840 //        context->calleeMetaIndex = initialIndex;

   841 //#ifndef Q_SCRIPT_NO_EVENT_NOTIFY

   842 //        engine->notifyFunctionEntry(context);

   843 //#endif

   844         if (!conversionFailed.isEmpty()) {

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

   846                               .arg(QLatin1String(funName));

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

   848                 if (i > 0)

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

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

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

   852             }

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

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

   855             QScriptMetaArguments argsInstance = unresolved.first();

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

   857             Q_ASSERT(unresolvedIndex != -1);

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

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

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

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

   862             if (unresolvedIndex > 0) {

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

   864                                arg(unresolvedIndex).arg(unresolvedTypeName));

   865             } else {

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

   867                                .arg(unresolvedTypeName));

   868             }

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

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

   871         } else {

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

   873                               .arg(QLatin1String(funName));

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

   875                 if (i > 0)

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

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

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

   879             }

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

   881         }

   882     } else {

   883         if (chosenIndex == -1) {

   884             QScriptMetaArguments metaArgs = candidates.at(0);

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

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

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

   888                 // ambiguous call

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

   890                                   .arg(QLatin1String(funName));

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

   892                     if (i > 0)

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

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

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

   896                 }

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

   898             } else {

   899                 chosenMethod = metaArgs.method;

   900                 chosenIndex = metaArgs.index;

   901                 args = metaArgs.args;

   902             }

   903         }

   904 

   905         if (chosenIndex != -1) {

   906             // call it

   907 //            context->calleeMetaIndex = chosenIndex;

   908 

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

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

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

   912                 const QVariant &v = args[i];

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

   914                 case QScriptMetaType::Variant:

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

   916                     break;

   917                 case QScriptMetaType::MetaType:

   918                 case QScriptMetaType::MetaEnum:

   919                 case QScriptMetaType::Unresolved:

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

   921                     break;

   922                 default:

   923                     Q_ASSERT(0);

   924                 }

   925             }

   926 

   927             QScriptable *scriptable = 0;

   928             if (thisQObject)

   929                 scriptable = scriptableFromQObject(thisQObject);

   930             QScriptEngine *oldEngine = 0;

   931             if (scriptable) {

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

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

   934             }

   935 

   936 // ### fixme

   937 //#ifndef Q_SCRIPT_NO_EVENT_NOTIFY

   938 //            engine->notifyFunctionEntry(context);

   939 //#endif

   940 

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

   942                 Q_ASSERT(meta != 0);

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

   944             } else {

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

   946             }

   947 

   948             if (scriptable)

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

   950 

   951             if (exec->hadException()) {

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

   953             } else {

   954                 QScriptMetaType retType = chosenMethod.returnType();

   955                 if (retType.isVariant()) {

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

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

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

   959                     if (!result) {

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

   961                         result = engine->scriptValueToJSCValue(sv);

   962                     }

   963                 } else {

   964                     result = JSC::jsUndefined();

   965                 }

   966             }

   967         }

   968     }

   969 

   970     return result;

   971 }

   972 

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

   974                                  const JSC::ArgList &scriptArgs)

   975 {

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

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

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

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

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

   981     if (!qobj)

   982         return JSC::throwError(exec, JSC::GeneralError, QString::fromLatin1("cannot call function of deleted QObject"));

   983     QScriptEnginePrivate *engine = scriptEngineFromExec(exec);

   984 

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

   986     QObject *thisQObject = 0;

   987     thisValue = engine->toUsableValue(thisValue);

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

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

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

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

   992     }

   993     if (!thisQObject)

   994         thisQObject = qobj; // ### TypeError

   995 

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

   997         // invoking a function in the prototype

   998         thisQObject = qobj;

   999     }

  1000 

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

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

  1003 }

  1004 

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

  1006 

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

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

  1009 {

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

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

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

  1013     QScriptEnginePrivate *eng_p = scriptEngineFromExec(exec);

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

  1015     eng_p->currentFrame = exec;

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

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

  1018     eng_p->popContext();

  1019     eng_p->currentFrame = previousFrame;

  1020     return result;

  1021 }

  1022 

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

  1024 

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

  1026                                        JSC::JSGlobalData *data,

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

  1028                                        const JSC::Identifier &ident)

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

  1030       data(new Data(meta, index))

  1031 {

  1032 }

  1033 

  1034 QtPropertyFunction::~QtPropertyFunction()

  1035 {

  1036     delete data;

  1037 }

  1038 

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

  1040 {

  1041     callData.native.function = call;

  1042     return JSC::CallTypeHost;

  1043 }

  1044 

  1045 JSC::JSValue JSC_HOST_CALL QtPropertyFunction::call(

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

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

  1048 {

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

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

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

  1052     QScriptEnginePrivate *eng_p = scriptEngineFromExec(exec);

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

  1054     eng_p->currentFrame = exec;

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

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

  1057     eng_p->popContext();

  1058     eng_p->currentFrame = previousFrame;

  1059     return result;

  1060 }

  1061 

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

  1063                                          JSC::JSValue thisValue,

  1064                                          const JSC::ArgList &args)

  1065 {

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

  1067 

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

  1069     QScriptEnginePrivate *engine = scriptEngineFromExec(exec);

  1070     thisValue = engine->toUsableValue(thisValue);

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

  1072     QObject *qobject = object.toQObject();

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

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

  1075         object = object.prototype();

  1076         qobject = object.toQObject();

  1077     }

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

  1079 

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

  1081     Q_ASSERT(prop.isScriptable());

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

  1083         // get

  1084         if (prop.isValid()) {

  1085             QScriptable *scriptable = scriptableFromQObject(qobject);

  1086             QScriptEngine *oldEngine = 0;

  1087             if (scriptable) {

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

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

  1090             }

  1091 

  1092             QVariant v = prop.read(qobject);

  1093 

  1094             if (scriptable)

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

  1096 

  1097             result = engine->jscValueFromVariant(v);

  1098         }

  1099     } else {

  1100         // set

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

  1102         QVariant v;

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

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

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

  1106             // string to enum value

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

  1108         } else {

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

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

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

  1112         }

  1113 

  1114         QScriptable *scriptable = scriptableFromQObject(qobject);

  1115         QScriptEngine *oldEngine = 0;

  1116         if (scriptable) {

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

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

  1119         }

  1120 

  1121         prop.write(qobject, v);

  1122 

  1123         if (scriptable)

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

  1125 

  1126         result = arg;

  1127     }

  1128     return result;

  1129 }

  1130 

  1131 const QMetaObject *QtPropertyFunction::metaObject() const

  1132 {

  1133     return data->meta;

  1134 }

  1135