void Test::activateSignal(const QString &signal, const QVariantList &args)
{
int metaIndex = d->signalName2Id.value(signal, -1);
if (metaIndex == -1) {
qWarning() << "dynamic signal" << signal << "doesn't exist";
return;
}
QMetaMethod sig = d->meta->method(metaIndex);
if (sig.parameterCount() != args.count()) {
qWarning() << "dynamic signal has" << sig.parameterCount() << "args"
<< args.count() << "provided";
return;
}
QVariantList argsCopy = args;
void * _a[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < sig.parameterCount(); ++i) {
if (!argsCopy[i].convert(sig.parameterType(i))) {
qWarning() << "dynamic signal" << signal << "wrong parameter" << i;
return;
}
_a[i + 1] = argsCopy[i].data();
}
QMetaObject::activate(this, d->meta, metaIndex - d->meta->methodOffset(), _a);
}
error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, void *func, int argsLen)
{
QObject *qobject = reinterpret_cast<QObject *>(object);
QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
QByteArray qsignal(signal, signalLen);
const QMetaObject *meta = qobject->metaObject();
// Walk backwards so descendants have priority.
for (int i = meta->methodCount()-1; i >= 0; i--) {
QMetaMethod method = meta->method(i);
if (method.methodType() == QMetaMethod::Signal) {
QByteArray name = method.name();
if (name.length() == signalLen && qstrncmp(name.constData(), signal, signalLen) == 0) {
if (method.parameterCount() < argsLen) {
// TODO Might continue looking to see if a different signal has the same name and enough arguments.
return errorf("signal \"%s\" has too few parameters for provided function", name.constData());
}
Connector *connector = Connector::New(qobject, method, qengine, func, argsLen);
const QMetaObject *connmeta = connector->metaObject();
QObject::connect(qobject, method, connector, connmeta->method(connmeta->methodOffset()));
return 0;
}
}
}
// Cannot use constData here as the byte array is not null-terminated.
return errorf("object does not expose a \"%s\" signal", qsignal.data());
}
int Test::qt_metacall(QMetaObject::Call call, int id, void **args)
{
id = QObject::qt_metacall(call, id, args);
if (id < 0 || !d->meta)
return id;
if (call == QMetaObject::InvokeMetaMethod) {
int metaIndex = id + d->meta->methodOffset();
QMetaMethod method = d->meta->method(metaIndex);
if (!method.isValid()) {
qWarning() << "invoked invalid method with id" << id;
return -1;
}
QVariantList vargs;
for (int i = 0; i < method.parameterCount(); ++i)
vargs.append(QVariant(method.parameterType(i), args[1 + i]));
QString catchedName = d->slotId2Name.value(metaIndex);
void *_a[] = { 0,
const_cast<void*>(reinterpret_cast<const void*>(&catchedName)),
const_cast<void*>(reinterpret_cast<const void*>(&vargs)) };
QMetaObject::activate(this, metaObject(), d->catchedSignalId, _a);
}
return -1;
}
JSValue QtInstance::stringValue(ExecState* exec) const
{
QObject* obj = getObject();
if (!obj)
return jsNull();
// Hmm.. see if there is a toString defined
QByteArray buf;
bool useDefault = true;
getClass();
if (m_class) {
// Cheat and don't use the full name resolution
int index = obj->metaObject()->indexOfMethod("toString()");
if (index >= 0) {
QMetaMethod m = obj->metaObject()->method(index);
// Check to see how much we can call it
if (m.access() != QMetaMethod::Private
&& m.methodType() != QMetaMethod::Signal
#if HAVE(QT5)
&& m.parameterCount() == 0
&& m.returnType() != QMetaType::Void) {
QVariant ret(m.returnType(), (void*)0);
void * qargs[1];
qargs[0] = ret.data();
if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, qargs) < 0) {
if (ret.isValid() && ret.canConvert(QVariant::String)) {
buf = ret.toString().toLatin1().constData(); // ### Latin 1? Ascii?
useDefault = false;
#else
&& m.parameterTypes().isEmpty()) {
const char* retsig = m.typeName();
if (retsig && *retsig) {
QVariant ret(QMetaType::type(retsig), (void*)0);
void * qargs[1];
qargs[0] = ret.data();
if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, qargs) < 0) {
if (ret.isValid() && ret.canConvert(QVariant::String)) {
buf = ret.toString().toLatin1().constData(); // ### Latin 1? Ascii?
useDefault = false;
}
#endif
}
}
}
}
}
if (useDefault) {
const QMetaObject* meta = obj ? obj->metaObject() : &QObject::staticMetaObject;
QString name = obj ? obj->objectName() : QString::fromUtf8("unnamed");
QString str = QString::fromUtf8("%0(name = \"%1\")")
.arg(QLatin1String(meta->className())).arg(name);
buf = str.toLatin1();
}
return jsString(exec, buf.constData());
}
QVector<int> metaMethodParamTypeIds(QMetaMethod m) {
QVector<int> ret;
int maxCnt = m.parameterCount();
for (int i = 0; i < maxCnt; i++) {
ret.push_back(m.parameterType(i));
}
return ret;
}
setter_method make_setter_method(const types_by_name &known_types, const QMetaMethod &meta_method)
{
auto parameter_type = meta_method.parameterCount() == 1
? type_by_pointer(known_types, meta_method.parameterTypes()[0].data())
: type{nullptr};
setter_method::validate_setter_method(parameter_type, meta_method);
return setter_method{parameter_type, meta_method};
}
factory_method::factory_method(type result_type, QMetaMethod meta_method) :
_object_type{meta_method.enclosingMetaObject()},
_result_type{std::move(result_type)},
_meta_method{std::move(meta_method)}
{
assert(meta_method.methodType() == QMetaMethod::Method || meta_method.methodType() == QMetaMethod::Slot);
assert(meta_method.parameterCount() == 0);
assert(meta_method.enclosingMetaObject() != nullptr);
assert(!_result_type.is_empty());
assert(_result_type.name() + "*" == std::string{meta_method.typeName()});
}
QString Util::prettyMethodSignature(const QMetaMethod& method)
{
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
return method.signature();
#else
QString signature = method.typeName();
signature += ' ' + method.name() + '(';
QStringList args;
args.reserve(method.parameterCount());
const QList<QByteArray> paramTypes = method.parameterTypes();
const QList<QByteArray> paramNames = method.parameterNames();
for (int i = 0; i < method.parameterCount(); ++i) {
QString arg = paramTypes.at(i);
if (!paramNames.at(i).isEmpty())
arg += ' ' + paramNames.at(i);
args.push_back(arg);
}
signature += args.join(QStringLiteral(", ")) + ')';
return signature;
#endif
}
void QFSignalProxy::bind(QObject *source, int signalIdx, QQmlEngine* engine, QFDispatcher* dispatcher)
{
const int memberOffset = QObject::staticMetaObject.methodCount();
QMetaMethod method = source->metaObject()->method(signalIdx);
parameterTypes = QVector<int>(method.parameterCount());
parameterNames = QVector<QString>(method.parameterCount());
type = method.name();
m_engine = engine;
m_dispatcher = dispatcher;
for (int i = 0 ; i < method.parameterCount() ; i++) {
parameterTypes[i] = method.parameterType(i);
parameterNames[i] = QString(method.parameterNames().at(i));
}
if (!QMetaObject::connect(source, signalIdx, this, memberOffset, Qt::AutoConnection, 0)) {
qWarning() << "Failed to bind signal";
}
}
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method,
const QVariantMap& args,
QVariantList& converted_args)
{
QList<QByteArray> param_types = meta_method.parameterTypes();
if (args.size() != param_types.size()) {
logError(QString("wrong number of arguments to method %1 -- "
"expected %2 arguments, but got %3")
.arg(QString(meta_method.methodSignature()))
.arg(meta_method.parameterCount())
.arg(args.size()));
return false;
}
for (int i = 0; i < param_types.size(); i++) {
QByteArray param_name = meta_method.parameterNames().at(i);
if (args.find(param_name) == args.end()) {
// no arg with param name found
return false;
}
const QVariant& arg = args.value(param_name);
if (!arg.isValid()) {
logError(QString("argument %1 of %2 to method %3 is invalid")
.arg(i + 1)
.arg(param_types.size())
.arg(QString(meta_method.methodSignature())));
return false;
}
QByteArray arg_type_name = arg.typeName();
QByteArray param_type_name = param_types.at(i);
QVariant::Type param_type = QVariant::nameToType(param_type_name);
QVariant copy = QVariant(arg);
if (copy.type() != param_type) {
if (copy.canConvert(param_type)) {
if (!copy.convert(param_type)) {
// qDebug() << "cannot convert" << arg_type_name
// << "to" << param_type_name;
return false;
}
}
}
converted_args << copy;
}
return true;
}
int DynamicQObject::qt_metacall(QMetaObject::Call call, int id, void **arguments)
{
printf("%d\n", call);
// Call default handlers in QObject first
id = QObject::qt_metacall(call, id, arguments);
if (id == -1 || call != QMetaObject::InvokeMetaMethod)
return id;
#if 0
Q_ASSERT(id < callbacks.count());
Callback *callback = callbacks[id];
int methodId = findSignalId(callback->signal);
// Convert parameters
HandleScope scope;
const QMetaObject *meta = obj->metaObject();
QMetaMethod method = meta->method(methodId);
int argc = method.parameterCount();
Handle<Value> *argv = new Handle<Value>[argc];
for (int i = 0; i < method.parameterCount(); ++i) {
int type = method.parameterType(i);
// Convert
argv[i] = Utils::QDataToV8(type, arguments[i + 1]);
}
// Invoke
MakeCallback(callback->handler, callback->handler, argc, argv);
// Release
delete [] argv;
#endif
return -1;
}
error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataValue *resultdv, DataValue *paramsdv, int paramsLen)
{
QObject *qobject = reinterpret_cast<QObject *>(object);
QVariant result;
QVariant param[MaxParams];
QGenericArgument arg[MaxParams];
for (int i = 0; i < paramsLen; i++) {
unpackDataValue(¶msdv[i], ¶m[i]);
arg[i] = Q_ARG(QVariant, param[i]);
}
if (paramsLen > 10) {
panicf("fix the parameter dispatching");
}
const QMetaObject *metaObject = qobject->metaObject();
// Walk backwards so descendants have priority.
for (int i = metaObject->methodCount()-1; i >= 0; i--) {
QMetaMethod metaMethod = metaObject->method(i);
QMetaMethod::MethodType methodType = metaMethod.methodType();
if (methodType == QMetaMethod::Method || methodType == QMetaMethod::Slot) {
QByteArray name = metaMethod.name();
if (name.length() == methodLen && qstrncmp(name.constData(), method, methodLen) == 0) {
if (metaMethod.parameterCount() < paramsLen) {
// TODO Might continue looking to see if a different signal has the same name and enough arguments.
return errorf("method \"%s\" has too few parameters for provided arguments", method);
}
bool ok;
if (metaMethod.returnType() == QMetaType::Void) {
ok = metaMethod.invoke(qobject, Qt::DirectConnection,
arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]);
} else {
ok = metaMethod.invoke(qobject, Qt::DirectConnection, Q_RETURN_ARG(QVariant, result),
arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]);
}
if (!ok) {
return errorf("invalid parameters to method \"%s\"", method);
}
packDataValue(&result, resultdv);
return 0;
}
}
}
return errorf("object does not expose a method \"%s\"", method);
}
bool action_method::validate_action_method(const QMetaMethod &meta_method)
{
auto meta_object = meta_method.enclosingMetaObject();
if (!meta_object)
throw exception::invalid_action{std::string{"action does not have enclosing meta object: "} + "?::" + meta_method.methodSignature().data()};
if (meta_method.methodType() == QMetaMethod::Signal)
throw exception::invalid_action{std::string{"action is signal: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
if (meta_method.methodType() == QMetaMethod::Constructor)
throw exception::invalid_action{std::string{"action is constructor: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
if (!is_action_init_tag(meta_method.tag()) && !is_action_done_tag(meta_method.tag()))
throw exception::invalid_action{std::string{"action does not have valid tag: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
if (meta_method.parameterCount() != 0)
throw exception::invalid_action{std::string{"invalid parameter count: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
return true;
}
QString ExtendedBase::fromMethodToCallbackFlag(const QMetaMethod &method)
{
QString buf;
buf += method.name();
buf += "(";
for(auto index = 0; index < method.parameterCount(); index++)
{
if(index)
{
buf += ",";
}
buf += method.parameterTypes()[index];
}
buf += ")";
return buf;
}
void tst_QQmlMetaObject::method()
{
QFETCH(QString, testFile);
QFETCH(QString, signature);
QFETCH(QMetaMethod::MethodType, methodType);
QFETCH(int, returnType);
QFETCH(QString, returnTypeName);
QFETCH(QList<int>, parameterTypes);
QFETCH(QList<QByteArray>, parameterTypeNames);
QFETCH(QList<QByteArray>, parameterNames);
QCOMPARE(parameterTypes.size(), parameterTypeNames.size());
QCOMPARE(parameterTypeNames.size(), parameterNames.size());
QQmlEngine engine;
QQmlComponent component(&engine, testFileUrl(testFile));
QObject *object = component.create();
QVERIFY(object != 0);
const QMetaObject *mo = object->metaObject();
QVERIFY(mo->superClass() != 0);
QVERIFY(QByteArray(mo->className()).contains("_QML_"));
QCOMPARE(mo->methodOffset(), mo->superClass()->methodCount());
QCOMPARE(mo->methodCount(), mo->superClass()->methodCount() + 1);
QMetaMethod method = mo->method(mo->methodOffset());
QCOMPARE(method.methodType(), methodType);
QCOMPARE(QString::fromUtf8(method.methodSignature().constData()), signature);
QCOMPARE(method.access(), QMetaMethod::Public);
QString computedName = signature.left(signature.indexOf('('));
QCOMPARE(QString::fromUtf8(method.name()), computedName);
QCOMPARE(method.parameterCount(), parameterTypes.size());
for (int i = 0; i < parameterTypes.size(); ++i)
QCOMPARE(method.parameterType(i), parameterTypes.at(i));
QCOMPARE(method.parameterTypes(), parameterTypeNames);
QCOMPARE(method.tag(), "");
QCOMPARE(QString::fromUtf8(method.typeName()), returnTypeName);
QCOMPARE(method.returnType(), returnType);
delete object;
}
void Bindable::checkParameterCount(const QMetaMethod &method, const int paramCount)
{
Q_ASSERT_X(method.parameterCount() == paramCount, "Bindable::wait",
qPrintable(QString("Incompatible argument count (expected %1, got %2)")
.arg(method.parameterCount(), paramCount)));
}
void tst_QQmlMetaObject::property()
{
QFETCH(QString, testFile);
QFETCH(QByteArray, cppTypeName);
QFETCH(int, cppType);
QFETCH(bool, isDefault);
QFETCH(QVariant, expectedValue);
QFETCH(bool, isWritable);
QFETCH(QVariant, newValue);
QQmlEngine engine;
QQmlComponent component(&engine, testFileUrl(testFile));
QObject *object = component.create();
QVERIFY(object != 0);
const QMetaObject *mo = object->metaObject();
QVERIFY(mo->superClass() != 0);
QVERIFY(QByteArray(mo->className()).contains("_QML_"));
QCOMPARE(mo->propertyOffset(), mo->superClass()->propertyCount());
QCOMPARE(mo->propertyCount(), mo->superClass()->propertyCount() + 1);
QMetaProperty prop = mo->property(mo->propertyOffset());
QCOMPARE(prop.name(), "test");
QCOMPARE(QByteArray(prop.typeName()), cppTypeName);
if (prop.userType() < QMetaType::User)
QCOMPARE(prop.type(), QVariant::Type(cppType));
else
QCOMPARE(prop.type(), QVariant::UserType);
QCOMPARE(prop.userType(), cppType);
QVERIFY(!prop.isConstant());
QVERIFY(!prop.isDesignable());
QVERIFY(!prop.isEnumType());
QVERIFY(!prop.isFinal());
QVERIFY(!prop.isFlagType());
QVERIFY(prop.isReadable());
QVERIFY(!prop.isResettable());
QVERIFY(prop.isScriptable());
QVERIFY(!prop.isStored());
QVERIFY(!prop.isUser());
QVERIFY(prop.isValid());
QCOMPARE(prop.isWritable(), isWritable);
QCOMPARE(mo->classInfoOffset(), mo->superClass()->classInfoCount());
QCOMPARE(mo->classInfoCount(), mo->superClass()->classInfoCount() + (isDefault ? 1 : 0));
if (isDefault) {
QMetaClassInfo info = mo->classInfo(mo->classInfoOffset());
QCOMPARE(info.name(), "DefaultProperty");
QCOMPARE(info.value(), "test");
}
QCOMPARE(mo->methodOffset(), mo->superClass()->methodCount());
QCOMPARE(mo->methodCount(), mo->superClass()->methodCount() + 1); // the signal
QVERIFY(prop.notifySignalIndex() != -1);
QMetaMethod signal = prop.notifySignal();
QCOMPARE(signal.methodType(), QMetaMethod::Signal);
QCOMPARE(signal.name(), QByteArray("testChanged"));
QCOMPARE(signal.methodSignature(), QByteArray("testChanged()"));
QCOMPARE(signal.access(), QMetaMethod::Public);
QCOMPARE(signal.parameterCount(), 0);
QCOMPARE(signal.parameterTypes(), QList<QByteArray>());
QCOMPARE(signal.parameterNames(), QList<QByteArray>());
QCOMPARE(signal.tag(), "");
QCOMPARE(signal.typeName(), "void");
QCOMPARE(signal.returnType(), int(QMetaType::Void));
QSignalSpy changedSpy(object, SIGNAL(testChanged()));
QObject::connect(object, SIGNAL(testChanged()), object, SLOT(deleteLater()));
if (expectedValue.isValid())
QCOMPARE(prop.read(object), expectedValue);
else
QVERIFY(prop.read(object).isValid());
QCOMPARE(changedSpy.count(), 0);
if (isWritable) {
QVERIFY(prop.write(object, newValue));
QCOMPARE(changedSpy.count(), 1);
QCOMPARE(prop.read(object), newValue);
} else {
QVERIFY(!prop.write(object, prop.read(object)));
QCOMPARE(changedSpy.count(), 0);
}
delete object;
}
void tst_QMetaMethod::method()
{
QFETCH(QByteArray, signature);
QFETCH(int, returnType);
QFETCH(QByteArray, returnTypeName);
QFETCH(QList<int>, parameterTypes);
QFETCH(QList<QByteArray>, parameterTypeNames);
QFETCH(QList<QByteArray>, parameterNames);
QFETCH(QMetaMethod::MethodType, methodType);
QFETCH(QMetaMethod::Access, access);
QVERIFY(parameterTypes.size() == parameterTypeNames.size());
QVERIFY(parameterTypes.size() == parameterNames.size());
const QMetaObject *mo = &MethodTestObject::staticMetaObject;
int index = (methodType == QMetaMethod::Constructor)
? mo->indexOfConstructor(signature) : mo->indexOfMethod(signature);
QVERIFY(index != -1);
QMetaMethod method = (methodType == QMetaMethod::Constructor)
? mo->constructor(index) : mo->method(index);
QVERIFY(method.isValid());
QCOMPARE(method.methodType(), methodType);
QCOMPARE(method.access(), access);
QVERIFY(!method.methodSignature().isEmpty());
if (method.methodSignature() != signature) {
// QMetaMethod should always produce a semantically equivalent signature
int signatureIndex = (methodType == QMetaMethod::Constructor)
? mo->indexOfConstructor(method.methodSignature())
: mo->indexOfMethod(method.methodSignature());
QCOMPARE(signatureIndex, index);
}
QByteArray computedName = signature.left(signature.indexOf('('));
QCOMPARE(method.name(), computedName);
QCOMPARE(method.tag(), "");
QCOMPARE(method.returnType(), returnType);
QVERIFY(method.typeName() != 0);
if (QByteArray(method.typeName()) != returnTypeName) {
// QMetaMethod should always produce a semantically equivalent typename
QCOMPARE(QMetaType::type(method.typeName()), QMetaType::type(returnTypeName));
}
if (method.parameterTypes() != parameterTypeNames) {
// QMetaMethod should always produce semantically equivalent typenames
QList<QByteArray> actualTypeNames = method.parameterTypes();
QCOMPARE(actualTypeNames.size(), parameterTypeNames.size());
for (int i = 0; i < parameterTypeNames.size(); ++i) {
QCOMPARE(QMetaType::type(actualTypeNames.at(i)),
QMetaType::type(parameterTypeNames.at(i)));
}
}
QCOMPARE(method.parameterNames(), parameterNames);
QCOMPARE(method.parameterCount(), parameterTypes.size());
for (int i = 0; i < parameterTypes.size(); ++i)
QCOMPARE(method.parameterType(i), parameterTypes.at(i));
{
QVector<int> actualParameterTypes(parameterTypes.size());
method.getParameterTypes(actualParameterTypes.data());
for (int i = 0; i < parameterTypes.size(); ++i)
QCOMPARE(actualParameterTypes.at(i), parameterTypes.at(i));
}
// Bogus indexes
QCOMPARE(method.parameterType(-1), 0);
QCOMPARE(method.parameterType(parameterTypes.size()), 0);
}
MethodParameters(int Index, const QMetaMethod &Method, int AllowedRequestTypes, const QString &ReturnType)
: m_valid(false),
m_index(Index),
m_allowedRequestTypes(AllowedRequestTypes),
m_returnType(ReturnType)
{
// statically initialise the list of unsupported types (either non-serialisable (QHash)
// or nonsensical (pointer types)
static QList<int> unsupportedtypes;
static QList<int> unsupportedparameters;
static bool initialised = false;
if (!initialised)
{
// this list is probably incomplete
initialised = true;
unsupportedtypes << QMetaType::UnknownType;
unsupportedtypes << QMetaType::VoidStar << QMetaType::QObjectStar << QMetaType::QVariantHash;
unsupportedtypes << QMetaType::QRect << QMetaType::QRectF << QMetaType::QSize << QMetaType::QSizeF << QMetaType::QLine << QMetaType::QLineF << QMetaType::QPoint << QMetaType::QPointF;
unsupportedparameters << unsupportedtypes;
unsupportedparameters << QMetaType::QVariantMap << QMetaType::QStringList << QMetaType::QVariantList;
}
// the return type/value is first
int returntype = QMetaType::type(Method.typeName());
// discard slots with an unsupported return type
if (unsupportedtypes.contains(returntype))
{
LOG(VB_GENERAL, LOG_ERR, QString("Method '%1' has unsupported return type '%2'").arg(Method.name().data()).arg(Method.typeName()));
return;
}
// discard overly complicated slots not supported by QMetaMethod
if (Method.parameterCount() > 10)
{
LOG(VB_GENERAL, LOG_ERR, QString("Method '%1' takes more than 10 parameters - ignoring").arg(Method.name().data()));
return;
}
m_types.append(returntype > 0 ? returntype : 0);
m_names.append(Method.name());
QList<QByteArray> names = Method.parameterNames();
QList<QByteArray> types = Method.parameterTypes();
// add type/value for each method parameter
for (int i = 0; i < names.size(); ++i)
{
int type = QMetaType::type(types[i]);
// discard slots that use unsupported parameter types
if (unsupportedparameters.contains(type))
{
LOG(VB_GENERAL, LOG_ERR, QString("Method '%1' has unsupported parameter type '%2'")
.arg(Method.name().data()).arg(types[i].data()));
return;
}
m_names.append(names[i]);
m_types.append(type);
}
m_valid = true;
}
// Parts of this function mirror code in QQmlExpressionPrivate::value() and v8value().
// Changes made here may need to be made there and vice versa.
void QQmlBoundSignalExpression::evaluate(void **a)
{
Q_ASSERT (context() && engine());
if (m_invalidParameterName)
return;
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine());
ep->referenceScarceResources(); // "hold" scarce resources in memory during evaluation.
{
v8::HandleScope handle_scope;
v8::Context::Scope context_scope(ep->v8engine()->context());
if (!m_expressionFunctionValid) {
//TODO: look at using the property cache here (as in the compiler)
// for further optimization
QMetaMethod signal = QMetaObjectPrivate::signal(m_target->metaObject(), m_index);
QQmlRewrite::RewriteSignalHandler rewriter;
QString expression;
bool ok = true;
if (m_expressionFunctionRewritten) {
expression = QString::fromUtf8(m_expressionUtf8);
//if we need parameters, and the rewrite doesn't include them,
//create and insert the parameter string now
if (m_parameterCountForJS == -1 && signal.parameterCount()) {
const QString ¶meters = rewriter.createParameterString(signal.parameterNames(),
ep->v8engine()->illegalNames());
int index = expression.indexOf(QLatin1Char('('), 1);
Q_ASSERT(index > -1);
expression.insert(index + 1, parameters);
setParameterCountForJS(rewriter.parameterCountForJS());
}
m_expressionUtf8.clear();
} else {
//expression is still in its original form, so perform a full rewrite
expression = rewriter(m_expression, QString()/*no name hint available*/, &ok,
signal.parameterNames(),
ep->v8engine()->illegalNames());
setParameterCountForJS(rewriter.parameterCountForJS());
m_expression.clear();
}
if (rewriter.hasParameterError()) {
qmlInfo(scopeObject()) << rewriter.parameterError();
m_invalidParameterName = true;
ep->dereferenceScarceResources();
return;
}
if (ok) {
m_v8function = evalFunction(context(), scopeObject(), expression,
m_fileName, m_line, &m_v8qmlscope);
}
if (m_v8function.IsEmpty() || m_v8function->IsNull()) {
ep->dereferenceScarceResources();
return; // could not evaluate function. Not valid.
}
setUseSharedContext(false);
m_expressionFunctionValid = true;
}
if (!hasParameterInfo()) {
QQmlJavaScriptExpression::evaluate(context(), m_v8function, 0);
} else {
QV8Engine *engine = ep->v8engine();
QVarLengthArray<int, 9> dummy;
//TODO: lookup via signal index rather than method index as an optimization
int methodIndex = QMetaObjectPrivate::signal(m_target->metaObject(), m_index).methodIndex();
int *argsTypes = QQmlPropertyCache::methodParameterTypes(m_target, methodIndex, dummy, 0);
int argCount = argsTypes ? m_parameterCountForJS : 0;
QVarLengthArray<v8::Handle<v8::Value>, 9> args(argCount);
for (int ii = 0; ii < argCount; ++ii) {
int type = argsTypes[ii + 1];
//### ideally we would use metaTypeToJS, however it currently gives different results
// for several cases (such as QVariant type and QObject-derived types)
//args[ii] = engine->metaTypeToJS(type, a[ii + 1]);
if (type == QMetaType::QVariant) {
args[ii] = engine->fromVariant(*((QVariant *)a[ii + 1]));
} else if (type == QMetaType::Int) {
//### optimization. Can go away if we switch to metaTypeToJS, or be expanded otherwise
args[ii] = v8::Integer::New(*reinterpret_cast<const int*>(a[ii + 1]));
} else if (type == qMetaTypeId<QQmlV8Handle>()) {
args[ii] = reinterpret_cast<QQmlV8Handle *>(a[ii + 1])->toHandle();
} else if (ep->isQObject(type)) {
if (!*reinterpret_cast<void* const *>(a[ii + 1]))
args[ii] = v8::Null();
else
args[ii] = engine->newQObject(*reinterpret_cast<QObject* const *>(a[ii + 1]));
} else {
args[ii] = engine->fromVariant(QVariant(type, a[ii + 1]));
}
}
QQmlJavaScriptExpression::evaluate(context(), m_v8function, argCount, args.data(), 0);
}
}
ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete.
}
