summaryrefslogtreecommitdiffstats
path: root/src/declarative
diff options
context:
space:
mode:
Diffstat (limited to 'src/declarative')
-rw-r--r--src/declarative/qml/qml.pri2
-rw-r--r--src/declarative/qml/qmlbasicscript.cpp10
-rw-r--r--src/declarative/qml/qmlbindingoptimizations.cpp87
-rw-r--r--src/declarative/qml/qmlbindingoptimizations_p.h34
-rw-r--r--src/declarative/qml/qmlbindingvme.cpp1519
-rw-r--r--src/declarative/qml/qmlbindingvme_p.h95
-rw-r--r--src/declarative/qml/qmlcompiler.cpp41
-rw-r--r--src/declarative/qml/qmlcompiler_p.h5
-rw-r--r--src/declarative/qml/qmlcontext_p.h4
-rw-r--r--src/declarative/qml/qmlinstruction.cpp3
-rw-r--r--src/declarative/qml/qmlinstruction_p.h3
-rw-r--r--src/declarative/qml/qmlvme.cpp21
12 files changed, 1817 insertions, 7 deletions
diff --git a/src/declarative/qml/qml.pri b/src/declarative/qml/qml.pri
index 1155a36..172146c 100644
--- a/src/declarative/qml/qml.pri
+++ b/src/declarative/qml/qml.pri
@@ -32,6 +32,7 @@ SOURCES += \
$$PWD/qmlenginedebug.cpp \
$$PWD/qmlrewrite.cpp \
$$PWD/qmlbasicscript.cpp \
+ $$PWD/qmlbindingvme.cpp \
$$PWD/qmlvaluetype.cpp \
$$PWD/qmlbindingoptimizations.cpp \
$$PWD/qmlxmlhttprequest.cpp \
@@ -94,6 +95,7 @@ HEADERS += \
$$PWD/qmlerror.h \
$$PWD/qmlscriptparser_p.h \
$$PWD/qmlbasicscript_p.h \
+ $$PWD/qmlbindingvme_p.h \
$$PWD/qmlenginedebug_p.h \
$$PWD/qmlrewrite_p.h \
$$PWD/qpodvector_p.h \
diff --git a/src/declarative/qml/qmlbasicscript.cpp b/src/declarative/qml/qmlbasicscript.cpp
index 6a32df7..b596437 100644
--- a/src/declarative/qml/qmlbasicscript.cpp
+++ b/src/declarative/qml/qmlbasicscript.cpp
@@ -121,6 +121,16 @@ public:
}
};
+// anchors.left: (nop convert)(qobject)parent.(anchorline)right
+
+/*
+ Property chains: a.b.c.d
+ if else value selection statements: if(a) b else if(c) d else e
+ trinary selection: a?b:c
+ addition: a + b
+ negation: a - a
+ equality: ==
+*/
static QVariant fetch_value(QObject *o, int idx, int type)
{
if (!o)
diff --git a/src/declarative/qml/qmlbindingoptimizations.cpp b/src/declarative/qml/qmlbindingoptimizations.cpp
index 0f2e199..120e07b 100644
--- a/src/declarative/qml/qmlbindingoptimizations.cpp
+++ b/src/declarative/qml/qmlbindingoptimizations.cpp
@@ -42,9 +42,96 @@
#include "qmlbindingoptimizations_p.h"
#include "qmlcontext_p.h"
+#include <QtDeclarative/qmlinfo.h>
+#include "qmlbindingvme_p.h"
QT_BEGIN_NAMESPACE
+int QmlBinding_Basic::reevalIndex = -1;
+
+QmlBinding_Basic::QmlBinding_Basic(QObject *target, int property,
+ const char *data, QmlRefCount *ref,
+ QObject *scope, QmlContext *context)
+: m_enabled(false), m_updating(false), m_scope(scope), m_target(target),
+ m_property(property), m_data(data)
+{
+ if (reevalIndex == -1)
+ reevalIndex = QmlBinding_Basic::staticMetaObject.indexOfSlot("reeval()");
+
+ m_config.target = this;
+ m_config.targetSlot = reevalIndex;
+ m_scope2 = m_scope;
+
+ QmlAbstractExpression::setContext(context);
+}
+
+QmlBinding_Basic::~QmlBinding_Basic()
+{
+}
+
+void QmlBinding_Basic::setEnabled(bool e, QmlMetaProperty::WriteFlags flags)
+{
+ if (e) {
+ addToObject(m_target);
+ update(flags);
+ } else {
+ removeFromObject();
+ }
+
+ QmlAbstractBinding::setEnabled(e, flags);
+
+ if (m_enabled != e) {
+ m_enabled = e;
+
+ if (e) update(flags);
+ }
+}
+
+int QmlBinding_Basic::propertyIndex()
+{
+ return m_property & 0xFFFF;
+}
+
+void QmlBinding_Basic::update(QmlMetaProperty::WriteFlags flags)
+{
+ if (!m_enabled)
+ return;
+
+ if (m_updating) {
+ qmlInfo(m_target) << tr("Binding loop detected");
+ return;
+ }
+
+ QmlContext *context = QmlAbstractExpression::context();
+ if (!context)
+ return;
+ QmlContextPrivate *cp = QmlContextPrivate::get(context);
+
+ m_updating = true;
+
+ if (m_property & 0xFFFF0000) {
+ QmlEnginePrivate *ep = QmlEnginePrivate::get(cp->engine);
+
+ QmlValueType *vt = ep->valueTypes[(m_property >> 16) & 0xFF];
+ Q_ASSERT(vt);
+ vt->read(m_target, m_property & 0xFFFF);
+
+ QObject *target = vt;
+ QmlBindingVME::run(m_data, &m_config, cp, &m_scope, &target);
+
+ vt->write(m_target, m_property & 0xFFFF, flags);
+ } else {
+ QmlBindingVME::run(m_data, &m_config, cp, &m_scope, &m_target);
+ }
+
+ m_updating = false;
+}
+
+void QmlBinding_Basic::reeval()
+{
+ update(QmlMetaProperty::DontRemoveBinding);
+}
+
/*
The QmlBinding_Id optimization handles expressions of the type:
diff --git a/src/declarative/qml/qmlbindingoptimizations_p.h b/src/declarative/qml/qmlbindingoptimizations_p.h
index 4ce145d..ee2eb83 100644
--- a/src/declarative/qml/qmlbindingoptimizations_p.h
+++ b/src/declarative/qml/qmlbindingoptimizations_p.h
@@ -55,11 +55,45 @@
#include "qmlexpression_p.h"
#include "qmlbinding.h"
+#include "qmlbasicscript_p.h"
+#include "qmlbindingvme_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
+class QmlBinding_Basic : public QObject,
+ public QmlAbstractExpression,
+ public QmlAbstractBinding
+{
+ Q_OBJECT
+public:
+ QmlBinding_Basic(QObject *target, int property,
+ const char *data, QmlRefCount *ref,
+ QObject *scope, QmlContext *context);
+ virtual ~QmlBinding_Basic();
+
+ // Inherited from QmlAbstractBinding
+ virtual void setEnabled(bool, QmlMetaProperty::WriteFlags flags);
+ virtual int propertyIndex();
+ virtual void update(QmlMetaProperty::WriteFlags flags);
+
+private slots:
+ void reeval();
+
+private:
+ bool m_enabled:1;
+ bool m_updating:1;
+ QObject *m_scope;
+ QObject *m_target;
+ int m_property;
+ const char *m_data;
+ QmlBindingVME::Config m_config;
+ QGuard<QObject> m_scope2;
+
+ static int reevalIndex;
+};
+
class QmlBinding_Id : public QmlAbstractExpression,
public QmlAbstractBinding
{
diff --git a/src/declarative/qml/qmlbindingvme.cpp b/src/declarative/qml/qmlbindingvme.cpp
new file mode 100644
index 0000000..26dd303
--- /dev/null
+++ b/src/declarative/qml/qmlbindingvme.cpp
@@ -0,0 +1,1519 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmlbindingvme_p.h"
+#include <private/qmlcontext_p.h>
+#include <private/qmljsast_p.h>
+#include <private/qmljsengine_p.h>
+#include <QtCore/qdebug.h>
+#include <private/qmlgraphicsanchors_p_p.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QmlJS;
+
+namespace {
+// Supported types: int, qreal, QString (needs constr/destr), QObject*, bool
+struct Register {
+ void setQObject(QObject *o) { *((QObject **)data) = o; }
+ QObject *getQObject() { return *((QObject **)data); }
+
+ void setqreal(qreal v) { *((qreal *)data) = v; }
+ qreal getqreal() { return *((qreal *)data); }
+
+ void setint(int v) { *((int *)data) = v; }
+ int getint() { return *((int *)data); }
+
+ void setbool(bool v) { *((bool *)data) = v; }
+ bool getbool() { return *((bool *)data); }
+
+ QVariant *getvariantptr() { return (QVariant *)typeDataPtr(); }
+
+ void *typeDataPtr() { return (void *)&data; }
+ void *typeMemory() { return (void *)data; }
+
+ void *data[2]; // Object stored here
+};
+
+struct Instr {
+ enum {
+ Init, // init
+
+ Subscribe, // subscribe
+ SubscribeId, // subscribe
+
+ LoadId, // load
+ LoadScope, // load
+ LoadRoot, // load
+
+ ConvertIntToReal, // unaryop
+ ConvertRealToInt, // unaryop
+
+ Real, // real_value
+ Int, // int_value
+ Bool, // bool_value
+
+ AddReal, // binaryop
+ AddInt, // binaryop
+
+ MinusReal, // binaryop
+ MinusInt, // binaryop
+
+ GreaterThanReal, // binaryop
+
+ NewString, // construct
+ CleanupString, // cleanup
+
+ Fetch, // fetch
+ Store, // store
+
+ Skip, // skip
+
+ Done,
+
+ // Speculative property resolution
+ InitString, // initstring
+ FindGeneric, // find
+ FindGenericTerminal, // find
+ FindProperty, // find
+ FindPropertyTerminal, // find
+ CleanupGeneric, // cleanup
+ ConvertGenericToReal, // genericunaryop
+ ConvertGenericToString, // genericunaryop
+
+ } type;
+
+ union {
+ struct {
+ int subscriptions;
+ int identifiers;
+ } init;
+ struct {
+ int offset;
+ int reg;
+ int index;
+ } subscribe;
+ struct {
+ int index;
+ int reg;
+ } load;
+ struct {
+ int output;
+ int index;
+ int reg;
+ } store;
+ struct {
+ int output;
+ int objectReg;
+ int index;
+ } fetch;
+ struct {
+ int reg;
+ } construct;
+ struct {
+ int reg;
+ qreal value;
+ } real_value;
+ struct {
+ int reg;
+ int value;
+ } int_value;
+ struct {
+ int reg;
+ bool value;
+ } bool_value;
+ struct {
+ int output;
+ int src1;
+ int src2;
+ } binaryop;
+ struct {
+ int output;
+ int src;
+ } unaryop;
+ struct {
+ int output;
+ int src;
+ int srcType;
+ } genericunaryop;
+ struct {
+ int reg;
+ int count;
+ } skip;
+ struct {
+ int reg;
+ int src;
+ int typeReg;
+ int name;
+ int subscribeIndex;
+ } find;
+ struct {
+ int reg;
+ int typeReg;
+ } cleanup;
+ struct {
+ int offset;
+ int dataIdx;
+ int length;
+ } initstring;
+ };
+};
+
+struct Program {
+ int dataLength;
+ const char *data() const { return ((const char *)this) + sizeof(Program); }
+ const Instr *instructions() const { return (const Instr *)(data() + dataLength); }
+};
+}
+
+struct QmlBindingCompiler
+{
+ struct Result {
+ Result() : unknownType(false), metaObject(0), type(-1), reg(-1) {}
+ bool operator==(const Result &o) const {
+ return unknownType == o.unknownType &&
+ metaObject == o.metaObject &&
+ type == o.type &&
+ reg == o.reg;
+ }
+ bool operator!=(const Result &o) const {
+ return !(*this == o);
+ }
+ bool unknownType;
+ const QMetaObject *metaObject;
+ int type;
+ int reg;
+ };
+
+ QmlBindingCompiler() : registers(0), strings(0) {}
+ void reset();
+
+ QmlParser::Object *context;
+ QmlParser::Object *component;
+ QmlParser::Property *destination;
+ QHash<QString, QmlParser::Object *> ids;
+
+ bool compile(QmlJS::AST::Node *);
+
+ bool parseExpression(QmlJS::AST::Node *, Result &);
+
+ bool tryName(QmlJS::AST::Node *);
+ bool parseName(QmlJS::AST::Node *, Result &);
+
+ bool tryArith(QmlJS::AST::Node *);
+ bool parseArith(QmlJS::AST::Node *, Result &);
+
+ bool tryLogic(QmlJS::AST::Node *);
+ bool parseLogic(QmlJS::AST::Node *, Result &);
+
+ bool tryConditional(QmlJS::AST::Node *);
+ bool parseConditional(QmlJS::AST::Node *, Result &);
+
+ bool tryConstant(QmlJS::AST::Node *);
+ bool parseConstant(QmlJS::AST::Node *, Result &);
+
+ bool buildName(QStringList &, QmlJS::AST::Node *);
+ Result fetch(const QMetaObject *, int reg, int idx, const QStringList &);
+
+ quint32 registers;
+ int acquireReg();
+ void releaseReg(int);
+
+ int registerString(const QString &);
+ int strings;
+ QByteArray data;
+
+ QSet<QString> subscriptionSet;
+ bool subscription(const QStringList &);
+ QVector<Instr> bytecode;
+};
+
+QByteArray QmlBindingVME::compile(const QmlBasicScript::Expression &expression)
+{
+ if (!expression.expression.asAST()) return false;
+
+ QmlBindingCompiler bsc;
+ bsc.context = expression.context;
+ bsc.component = expression.component;
+ bsc.destination = expression.property;
+ bsc.ids = expression.ids;
+
+ bool ok = bsc.compile(expression.expression.asAST());
+
+ if (ok) {
+ Program prog;
+ prog.dataLength = 4 * ((bsc.data.size() + 3) / 4);
+ int size = sizeof(Program) + bsc.bytecode.count() * sizeof(Instr);
+ size += prog.dataLength;
+
+ QByteArray data;
+ data.resize(size);
+ memcpy(data.data(), &prog, sizeof(Program));
+ if (prog.dataLength)
+ memcpy((char *)((Program *)data.data())->data(), bsc.data.constData(),
+ bsc.data.size());
+ memcpy((char *)((Program *)data.data())->instructions(), bsc.bytecode.constData(),
+ bsc.bytecode.count() * sizeof(Instr));
+ return data;
+ } else {
+ return QByteArray();
+ }
+}
+
+inline void subscribe(QObject *o, int notifyIndex, QmlBindingVME::Config::Subscription *s,
+ QmlBindingVME::Config *config)
+{
+ if (o != s->source || notifyIndex != s->notifyIndex) {
+ if (s->source)
+ QMetaObject::disconnect(s->source, s->notifyIndex,
+ config->target, config->targetSlot);
+ s->source = o;
+ s->notifyIndex = notifyIndex;
+ if (s->source && s->notifyIndex != -1)
+ QMetaObject::connect(s->source, s->notifyIndex, config->target,
+ config->targetSlot, Qt::DirectConnection);
+ }
+}
+
+static QObject *variantToQObject(const QVariant &value, bool *ok)
+{
+ *ok = false;
+ Q_UNUSED(value);
+ return 0;
+}
+
+static QmlPropertyCache::Data *findproperty(QObject *obj,
+ const QScriptDeclarativeClass::Identifier &name,
+ QmlEnginePrivate *enginePriv,
+ QmlPropertyCache::Data &local)
+{
+ QmlPropertyCache *cache = 0;
+ QmlDeclarativeData *ddata = QmlDeclarativeData::get(obj);
+ if (ddata)
+ cache = ddata->propertyCache;
+ if (!cache) {
+ cache = enginePriv->cache(obj);
+ if (cache && ddata) { cache->addref(); ddata->propertyCache = cache; }
+ }
+
+ QmlPropertyCache::Data *property = 0;
+
+ if (cache) {
+ property = cache->property(name);
+ } else {
+ qWarning() << "QmlBindingVME: Slow search" << enginePriv->objectClass->toString(name);
+ local = QmlPropertyCache::create(obj->metaObject(),
+ enginePriv->objectClass->toString(name));
+ if (local.isValid())
+ property = &local;
+ }
+
+ return property;
+}
+
+static bool findproperty(QObject *obj,
+ Register *output, Register *type,
+ QmlEnginePrivate *enginePriv,
+ QmlBindingVME::Config *config, int subIdx,
+ const QScriptDeclarativeClass::Identifier &name,
+ bool isTerminal)
+{
+ QmlPropertyCache::Data local;
+ QmlPropertyCache::Data *property = findproperty(obj, name, enginePriv, local);
+
+ if (property) {
+ if (property->flags & QmlPropertyCache::Data::IsQObjectDerived) {
+ void *args[] = { output->typeDataPtr(), 0 };
+ QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);
+ type->setint(QMetaType::QObjectStar);
+ } else if (property->propType == qMetaTypeId<QVariant>()) {
+ QVariant v;
+ void *args[] = { &v, 0 };
+ QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);
+
+ if (isTerminal) {
+ new (output->typeDataPtr()) QVariant(v);
+ type->setint(qMetaTypeId<QVariant>());
+ } else {
+ bool ok;
+ output->setQObject(variantToQObject(v, &ok));
+ if (!ok) return false;
+ type->setint(QMetaType::QObjectStar);
+ }
+
+ } else {
+ if (!isTerminal)
+ return false;
+
+ if (property->propType == QMetaType::QReal) {
+ void *args[] = { output->typeDataPtr(), 0 };
+ QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);
+ type->setint(QMetaType::QReal);
+ } else {
+ new (output->typeDataPtr())
+ QVariant(obj->metaObject()->property(property->coreIndex).read(obj));
+ type->setint(qMetaTypeId<QVariant>());
+ }
+
+ }
+
+ if (subIdx != -1)
+ subscribe(obj, property->notifyIndex, config->subscriptions + subIdx, config);
+
+ return true;
+ } else {
+ return false;
+ }
+}
+
+static bool findproperty(Register *input,
+ Register *output, Register *type,
+ QmlEnginePrivate *enginePriv,
+ QmlBindingVME::Config *config, int subIdx,
+ const QScriptDeclarativeClass::Identifier &name,
+ bool isTerminal)
+{
+ return findproperty(input->getQObject(), output, type, enginePriv,
+ config, subIdx, name, isTerminal);
+}
+
+static bool findgeneric(Register *output, // value output
+ Register *type, // value type output
+ QmlBindingVME::Config *config,
+ int subIdx, // Subscription index in config
+ QmlContextPrivate *context, // Context to search in
+ const QScriptDeclarativeClass::Identifier &name,
+ bool isTerminal)
+{
+ QmlEnginePrivate *enginePriv = QmlEnginePrivate::get(context->engine);
+
+ while (context) {
+
+ int contextPropertyIndex = context->propertyNames?context->propertyNames->value(name):-1;
+ if (contextPropertyIndex != -1) {
+
+ if (contextPropertyIndex < context->idValueCount) {
+ output->setQObject(context->idValues[contextPropertyIndex]);
+ type->setint(QMetaType::QObjectStar);
+ } else {
+ const QVariant &value = context->propertyValues.at(contextPropertyIndex);
+ if (isTerminal) {
+ new (output->typeDataPtr()) QVariant(value);
+ type->setint(qMetaTypeId<QVariant>());
+ } else {
+ bool ok;
+ output->setQObject(variantToQObject(value, &ok));
+ if (!ok) return false;
+ type->setint(QMetaType::QObjectStar);
+ }
+ }
+
+ return true;
+ }
+
+ for (int ii = 0; ii < context->scripts.count(); ++ii) {
+ QScriptValue function = QScriptDeclarativeClass::function(context->scripts.at(ii), name);
+ if (function.isValid()) {
+ qFatal("Binding optimizer resolved name to QScript method");
+ return false;
+ }
+ }
+
+ if (QObject *root = context->defaultObjects.isEmpty()?0:context->defaultObjects.first()) {
+
+ if (findproperty(root, output, type, enginePriv, config, subIdx, name, isTerminal))
+ return true;
+
+ }
+
+ if (context->parent) {
+ context = QmlContextPrivate::get(context->parent);
+ } else {
+ context = 0;
+ }
+ }
+
+ return false;
+}
+
+
+// Conversion functions
+inline static qreal toReal(Register *reg, int type, bool *ok = 0)
+{
+ if (ok) *ok = true;
+
+ if (type == QMetaType::QReal) {
+ return reg->getqreal();
+ } else if (type == qMetaTypeId<QVariant>()) {
+ *ok = true;
+ return reg->getvariantptr()->toReal();
+ } else {
+ if (ok) *ok = false;
+ return 0;
+ }
+}
+
+inline static QString toString(Register *reg, int type, bool *ok = 0)
+{
+ if (ok) *ok = true;
+
+ if (type == QMetaType::QReal) {
+ return QString::number(reg->getqreal());
+ } else if (type == qMetaTypeId<QVariant>()) {
+ return reg->getvariantptr()->toString();
+ } else {
+ if (ok) *ok = false;
+ return QString();
+ }
+}
+
+inline static bool toBool(Register *reg, int type, bool *ok = 0)
+{
+ if (ok) *ok = true;
+
+ if (type == QMetaType::Bool) {
+ return reg->getbool();
+ } else if (type == qMetaTypeId<QVariant>()) {
+ return reg->getvariantptr()->toBool();
+ } else {
+ if (ok) *ok = false;
+ return false;
+ }
+}
+
+inline static QUrl toUrl(Register *reg, int type, QmlContextPrivate *context, bool *ok = 0)
+{
+ if (ok) *ok = true;
+
+ QUrl base;
+ if (type == qMetaTypeId<QVariant>()) {
+ QVariant *var = reg->getvariantptr();
+ int vt = var->type();
+ if (vt == QVariant::Url) {
+ base = var->toUrl();
+ } else if (vt == QVariant::ByteArray) {
+ base = QUrl(QString::fromUtf8(var->toByteArray()));
+ } else if (vt == QVariant::String) {
+ base = QUrl(var->toString());
+ } else {
+ if (ok) *ok = false;
+ return QUrl();
+ }
+ } else {
+ if (ok) *ok = false;
+ return QUrl();
+ }
+
+ return QUrl();
+}
+
+void QmlBindingVME::run(const char *programData, Config *config,
+ QmlContextPrivate *context,
+ QObject **scopes, QObject **outputs)
+{
+ Register registers[32];
+ int storeFlags = 0;
+
+ QmlEnginePrivate *engine = QmlEnginePrivate::get(context->engine);
+ Program *program = (Program *)programData;
+ const Instr *instr = program->instructions();
+ const char *data = program->data();
+
+ while (instr) {
+
+ switch (instr->type) {
+ case Instr::Init:
+ if (!config->subscriptions && instr->init.subscriptions)
+ config->subscriptions = new Config::Subscription[instr->init.subscriptions];
+ if (!config->identifiers && instr->init.identifiers)
+ config->identifiers = new QScriptDeclarativeClass::PersistentIdentifier[instr->init.identifiers];
+ break;
+
+ case Instr::SubscribeId:
+ case Instr::Subscribe:
+ {
+ QObject *o = registers[instr->subscribe.reg].getQObject();
+ Config::Subscription *s = config->subscriptions + instr->subscribe.offset;
+ int notifyIndex = instr->subscribe.index;
+
+ if (instr->type == Instr::SubscribeId) {
+ o = QmlContextPrivate::get(context);
+ notifyIndex += context->notifyIndex;
+ }
+
+ subscribe(o, instr->subscribe.index, s, config);
+ }
+ break;
+
+ case Instr::LoadId:
+ registers[instr->load.reg].setQObject(context->idValues[instr->load.index].data());
+ break;
+
+ case Instr::LoadScope:
+ registers[instr->load.reg].setQObject(scopes[instr->load.index]);
+ break;
+
+ case Instr::LoadRoot:
+ registers[instr->load.reg].setQObject(context->defaultObjects.at(0));
+ break;
+
+ case Instr::ConvertIntToReal:
+ registers[instr->unaryop.output].setqreal(qreal(registers[instr->unaryop.src].getint()));
+ break;
+
+ case Instr::ConvertRealToInt:
+ registers[instr->unaryop.output].setint(int(registers[instr->unaryop.src].getqreal()));
+ break;
+
+ case Instr::Real:
+ registers[instr->real_value.reg].setqreal(instr->real_value.value);
+ break;
+
+ case Instr::Int:
+ registers[instr->int_value.reg].setint(instr->int_value.value);
+ break;
+
+ case Instr::Bool:
+ registers[instr->bool_value.reg].setbool(instr->bool_value.value);
+ break;
+
+ case Instr::AddReal:
+ registers[instr->binaryop.output].setqreal(registers[instr->binaryop.src1].getqreal() +
+ registers[instr->binaryop.src2].getqreal());
+ break;
+
+ case Instr::AddInt:
+ registers[instr->binaryop.output].setint(registers[instr->binaryop.src1].getint() +
+ registers[instr->binaryop.src2].getint());
+ break;
+
+ case Instr::MinusReal:
+ registers[instr->binaryop.output].setqreal(registers[instr->binaryop.src1].getqreal() -
+ registers[instr->binaryop.src2].getqreal());
+ break;
+
+ case Instr::MinusInt:
+ registers[instr->binaryop.output].setint(registers[instr->binaryop.src1].getint() -
+ registers[instr->binaryop.src2].getint());
+ break;
+
+ case Instr::GreaterThanReal:
+ registers[instr->binaryop.output].setbool(registers[instr->binaryop.src1].getqreal() >
+ registers[instr->binaryop.src2].getqreal());
+ break;
+
+ case Instr::NewString:
+ new (registers[instr->construct.reg].typeMemory()) QString;
+ break;
+
+ case Instr::CleanupString:
+ ((QString *)(registers[instr->cleanup.reg].typeDataPtr()))->~QString();
+ break;
+
+ case Instr::Fetch:
+ {
+ QObject *object = registers[instr->fetch.objectReg].getQObject();
+ if (!object) {
+ qWarning() << "ERROR - Fetch";
+ return;
+ }
+ void *argv[] = { registers[instr->fetch.output].typeDataPtr(), 0 };
+ QMetaObject::metacall(object, QMetaObject::ReadProperty, instr->fetch.index, argv);
+ }
+ break;
+
+ case Instr::Store:
+ {
+ int status = -1;
+ void *argv[] = { registers[instr->store.reg].typeDataPtr(),
+ 0, &status, &storeFlags };
+ QMetaObject::metacall(outputs[instr->store.output], QMetaObject::WriteProperty,
+ instr->store.index, argv);
+ }
+ break;
+
+ case Instr::Skip:
+ if (instr->skip.reg == -1 || !registers[instr->skip.reg].getbool())
+ instr += instr->skip.count;
+ break;
+
+ case Instr::Done:
+ return;
+
+ case Instr::InitString:
+ if (!config->identifiers[instr->initstring.offset].identifier) {
+ QString str = QString::fromRawData((QChar *)(data + instr->initstring.dataIdx),
+ instr->initstring.length);
+ config->identifiers[instr->initstring.offset] =
+ engine->objectClass->createPersistentIdentifier(str);
+ }
+ break;
+
+ case Instr::FindGenericTerminal:
+ case Instr::FindGeneric:
+ // We start the search in the parent context, as we know that the
+ // name is not present in the current context or it would have been
+ // found during the static compile
+ if (!findgeneric(registers + instr->find.reg, registers + instr->find.typeReg,
+ config, instr->find.subscribeIndex, QmlContextPrivate::get(context->parent),
+ config->identifiers[instr->find.name].identifier,
+ instr->type == Instr::FindGenericTerminal)) {
+ qWarning() << "ERROR - FindGeneric*";
+ return;
+ }
+ break;
+
+ case Instr::FindPropertyTerminal:
+ case Instr::FindProperty:
+ if (!findproperty(registers + instr->find.src,
+ registers + instr->find.reg, registers + instr->find.typeReg,
+ QmlEnginePrivate::get(context->engine),
+ config, instr->find.subscribeIndex,
+ config->identifiers[instr->find.name].identifier,
+ instr->type == Instr::FindPropertyTerminal)) {
+ qWarning() << "ERROR - FindProperty*";
+ return;
+ }
+ break;
+
+ case Instr::CleanupGeneric:
+ {
+ int type = registers[instr->cleanup.typeReg].getint();
+ if (type == qMetaTypeId<QVariant>()) {
+ ((QVariant *)registers[instr->cleanup.reg].typeDataPtr())->~QVariant();
+ }
+ }
+ break;
+
+ case Instr::ConvertGenericToReal:
+ {
+ int type = registers[instr->genericunaryop.srcType].getint();
+ registers[instr->genericunaryop.output].setqreal(toReal(registers + instr->genericunaryop.src, type));
+ }
+ break;
+
+ case Instr::ConvertGenericToString:
+ {
+ int type = registers[instr->genericunaryop.srcType].getint();
+ void *regPtr = registers[instr->genericunaryop.output].typeDataPtr();
+ new (regPtr) QString(toString(registers + instr->genericunaryop.src, type));
+ }
+ break;
+
+ default:
+ qFatal("EEK");
+ break;
+ }
+
+ instr++;
+ }
+}
+
+void QmlBindingVME::dump(const QByteArray &programData)
+{
+ const Program *program = (const Program *)programData.constData();
+
+ int count = (programData.size() - sizeof(Program) - program->dataLength) / sizeof(Instr);
+ const Instr *instr = program->instructions();
+
+ while (count--) {
+
+ switch (instr->type) {
+ case Instr::Init:
+ qWarning().nospace() << "Init" << "\t\t\t" << instr->init.subscriptions << "\t" << instr->init.identifiers;
+ break;
+ case Instr::Subscribe:
+ qWarning().nospace() << "Subscribe" << "\t\t" << instr->subscribe.offset << "\t" << instr->subscribe.reg << "\t" << instr->subscribe.index;
+ break;
+ case Instr::SubscribeId:
+ qWarning().nospace() << "SubscribeId" << "\t\t" << instr->subscribe.offset << "\t" << instr->subscribe.reg << "\t" << instr->subscribe.index;
+ break;
+ case Instr::LoadId:
+ qWarning().nospace() << "LoadId" << "\t\t\t" << instr->load.index << "\t" << instr->load.reg;
+ break;
+ case Instr::LoadScope:
+ qWarning().nospace() << "LoadScope" << "\t\t" << instr->load.index << "\t" << instr->load.reg;
+ break;
+ case Instr::LoadRoot:
+ qWarning().nospace() << "LoadRoot" << "\t\t" << instr->load.index << "\t" << instr->load.reg;
+ break;
+ case Instr::ConvertIntToReal:
+ qWarning().nospace() << "ConvertIntToReal" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;
+ break;
+ case Instr::ConvertRealToInt:
+ qWarning().nospace() << "ConvertRealToInt" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;
+ break;
+ case Instr::Real:
+ qWarning().nospace() << "Real" << "\t\t\t" << instr->real_value.reg << "\t" << instr->real_value.value;
+ break;
+ case Instr::Int:
+ qWarning().nospace() << "Int" << "\t\t\t" << instr->int_value.reg << "\t" << instr->int_value.value;
+ break;
+ case Instr::Bool:
+ qWarning().nospace() << "Bool" << "\t\t\t" << instr->bool_value.reg << "\t" << instr->bool_value.value;
+ break;
+ case Instr::AddReal:
+ qWarning().nospace() << "AddReal" << "\t\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;
+ break;
+ case Instr::AddInt:
+ qWarning().nospace() << "AddInt" << "\t\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;
+ break;
+ case Instr::MinusReal:
+ qWarning().nospace() << "MinusReal" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;
+ break;
+ case Instr::MinusInt:
+ qWarning().nospace() << "MinusInt" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;
+ break;
+ case Instr::GreaterThanReal:
+ qWarning().nospace() << "GreaterThanReal" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;
+ break;
+ case Instr::NewString:
+ qWarning().nospace() << "NewString" << "\t\t" << instr->construct.reg;
+ break;
+ case Instr::CleanupString:
+ qWarning().nospace() << "CleanupString" << "\t\t" << instr->cleanup.reg << "\t" << instr->cleanup.typeReg;
+ break;
+ case Instr::Fetch:
+ qWarning().nospace() << "Fetch" << "\t\t\t" << instr->fetch.output << "\t" << instr->fetch.index << "\t" << instr->fetch.objectReg;
+ break;
+ case Instr::Store:
+ qWarning().nospace() << "Store" << "\t\t\t" << instr->store.output << "\t" << instr->store.index << "\t" << instr->store.reg;
+ break;
+ case Instr::Skip:
+ qWarning().nospace() << "Skip" << "\t\t\t" << instr->skip.reg << "\t" << instr->skip.count;
+ break;
+ case Instr::Done:
+ qWarning().nospace() << "Done";
+ break;
+ case Instr::InitString:
+ qWarning().nospace() << "InitString" << "\t\t" << instr->initstring.offset << "\t" << instr->initstring.dataIdx << "\t" << instr->initstring.length;
+ break;
+ case Instr::FindGeneric:
+ qWarning().nospace() << "FindGeneric" << "\t\t" << instr->find.reg << "\t" << instr->find.typeReg << "\t" << instr->find.name;
+ break;
+ case Instr::FindGenericTerminal:
+ qWarning().nospace() << "FindGenericTerminal" << "\t" << instr->find.reg << "\t" << instr->find.typeReg << "\t" << instr->find.name;
+ break;
+ case Instr::FindProperty:
+ qWarning().nospace() << "FindProperty" << "\t\t" << instr->find.reg << "\t" << instr->find.src << "\t" << instr->find.typeReg << "\t" << instr->find.name;
+ break;
+ case Instr::FindPropertyTerminal:
+ qWarning().nospace() << "FindPropertyTerminal" << "\t\t" << instr->find.reg << "\t" << instr->find.src << "\t" << instr->find.typeReg << "\t" << instr->find.name;
+ break;
+ case Instr::CleanupGeneric:
+ qWarning().nospace() << "CleanupGeneric" << "\t\t" << instr->cleanup.reg << "\t" << instr->cleanup.typeReg;
+ break;
+ case Instr::ConvertGenericToReal:
+ qWarning().nospace() << "ConvertGenericToReal" << "\t" << instr->genericunaryop.output << "\t" << instr->genericunaryop.src << "\t" << instr->genericunaryop.srcType;
+ break;
+ case Instr::ConvertGenericToString:
+ qWarning().nospace() << "ConvertGenericToString" << "\t" << instr->genericunaryop.output << "\t" << instr->genericunaryop.src << "\t" << instr->genericunaryop.srcType;
+ break;
+ default:
+ qWarning().nospace() << "Unknown";
+ break;
+ }
+
+ ++instr;
+ }
+}
+
+void QmlBindingCompiler::reset()
+{
+ registers = 0;
+ strings = 0;
+ data.clear();
+ subscriptionSet.clear();
+ bytecode.clear();
+}
+
+bool QmlBindingCompiler::compile(QmlJS::AST::Node *node)
+{
+ reset();
+
+ Result type;
+
+ if (!parseExpression(node, type))
+ return false;
+
+ if (subscriptionSet.count() || strings) {
+ if (subscriptionSet.count() > 0xFFFF ||
+ strings > 0xFFFF)
+ return false;
+
+ Instr init;
+ init.type = Instr::Init;
+ init.init.subscriptions = subscriptionSet.count();
+ init.init.identifiers = strings;
+ bytecode.prepend(init);
+ }
+
+ if (type.unknownType) {
+ if (destination->type != QMetaType::QReal &&
+ destination->type != QVariant::String)
+ return false;
+
+ int convertReg = acquireReg();
+
+ if (destination->type == QMetaType::QReal) {
+ Instr convert;
+ convert.type = Instr::ConvertGenericToReal;
+ convert.genericunaryop.output = convertReg;
+ convert.genericunaryop.src = type.reg;
+ convert.genericunaryop.srcType = 2; // XXX
+ bytecode << convert;
+ } else if (destination->type == QVariant::String) {
+ Instr convert;
+ convert.type = Instr::ConvertGenericToString;
+ convert.genericunaryop.output = convertReg;
+ convert.genericunaryop.src = type.reg;
+ convert.genericunaryop.srcType = 2; // XXX
+ bytecode << convert;
+ }
+
+ Instr cleanup;
+ cleanup.type = Instr::CleanupGeneric;
+ cleanup.cleanup.reg = type.reg;
+ cleanup.cleanup.typeReg = 2; // XXX
+ bytecode << cleanup;
+
+ Instr instr;
+ instr.type = Instr::Store;
+ instr.store.output = 0;
+ instr.store.index = destination->index;
+ instr.store.reg = convertReg;
+ bytecode << instr;
+
+ if (destination->type == QVariant::String) {
+ Instr cleanup;
+ cleanup.type = Instr::CleanupString;
+ cleanup.cleanup.reg = convertReg;
+ cleanup.cleanup.typeReg = -1;
+ bytecode << cleanup;
+ }
+
+ releaseReg(convertReg);
+
+ Instr done;
+ done.type = Instr::Done;
+ bytecode << done;
+
+ return true;
+ } else {
+ // Can we store the final value?
+ if (type.type == QVariant::Int &&
+ destination->type == QMetaType::QReal) {
+ Instr instr;
+ instr.type = Instr::ConvertIntToReal;
+ instr.unaryop.output = type.reg;
+ instr.unaryop.src = type.reg;
+ bytecode << instr;
+ type.type = QMetaType::QReal;
+ } else if (type.type == QMetaType::QReal &&
+ destination->type == QVariant::Int) {
+ Instr instr;
+ instr.type = Instr::ConvertRealToInt;
+ instr.unaryop.output = type.reg;
+ instr.unaryop.src = type.reg;
+ bytecode << instr;
+ type.type = QVariant::Int;
+ } else if (type.type == destination->type) {
+ } else {
+ const QMetaObject *from = type.metaObject;
+ const QMetaObject *to = QmlMetaType::rawMetaObjectForType(destination->type);
+
+ if (QmlMetaPropertyPrivate::canConvert(from, to))
+ type.type = destination->type;
+ }
+
+ if (type.type == destination->type) {
+ Instr instr;
+ instr.type = Instr::Store;
+ instr.store.output = 0;
+ instr.store.index = destination->index;
+ instr.store.reg = type.reg;
+ bytecode << instr;
+
+ Instr done;
+ done.type = Instr::Done;
+ bytecode << done;
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
+
+bool QmlBindingCompiler::parseExpression(QmlJS::AST::Node *node, Result &type)
+{
+ while (node->kind == AST::Node::Kind_NestedExpression)
+ node = static_cast<AST::NestedExpression *>(node)->expression;
+
+ if (tryArith(node)) {
+ if (!parseArith(node, type)) return false;
+ } else if (tryLogic(node)) {
+ if (!parseLogic(node, type)) return false;
+ } else if (tryConditional(node)) {
+ if (!parseConditional(node, type)) return false;
+ } else if (tryName(node)) {
+ if (!parseName(node, type)) return false;
+ } else if (tryConstant(node)) {
+ if (!parseConstant(node, type)) return false;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool QmlBindingCompiler::tryName(QmlJS::AST::Node *node)
+{
+ return node->kind == AST::Node::Kind_IdentifierExpression ||
+ node->kind == AST::Node::Kind_FieldMemberExpression;
+}
+
+bool QmlBindingCompiler::parseName(AST::Node *node, Result &type)
+{
+ QStringList nameParts;
+ if (!buildName(nameParts, node))
+ return false;
+
+ int reg = acquireReg();
+ if (reg == -1)
+ return false;
+ type.reg = reg;
+
+ QmlParser::Object *absType = 0;
+
+ QStringList subscribeName;
+
+ for (int ii = 0; ii < nameParts.count(); ++ii) {
+ const QString &name = nameParts.at(ii);
+
+ // We don't handle signal properties or attached properties
+ if (name.length() > 2 && name.startsWith(QLatin1String("on")) &&
+ name.at(2).isUpper())
+ return false;
+ if (name.at(0).isUpper())
+ return false;
+
+
+ if (ii == 0) {
+
+ if (ids.contains(name)) {
+ QmlParser::Object *idObject = ids.value(name);
+ absType = idObject;
+ type.metaObject = absType->metaObject();
+
+ // We check if the id object is the root or
+ // scope object to avoid a subscription
+ if (idObject == component) {
+ Instr instr;
+ instr.type = Instr::LoadRoot;
+ instr.load.index = 0;
+ instr.load.reg = reg;
+ bytecode << instr;
+ } else if (idObject == context) {
+ Instr instr;
+ instr.type = Instr::LoadScope;
+ instr.load.index = 0;
+ instr.load.reg = reg;
+ bytecode << instr;
+ } else {
+ Instr instr;
+ instr.type = Instr::LoadId;
+ instr.load.index = idObject->idIndex;
+ instr.load.reg = reg;
+ bytecode << instr;
+
+ subscribeName << QLatin1String("$$$ID_") + name;
+
+ if (subscription(subscribeName)) {
+ Instr sub;
+ sub.type = Instr::SubscribeId;
+ sub.subscribe.offset = subscriptionSet.count() - 1;
+ sub.subscribe.reg = reg;
+ sub.subscribe.index = instr.load.index;
+ bytecode << sub;
+ }
+ }
+
+ } else {
+
+ QByteArray utf8Name = name.toUtf8();
+ const char *cname = utf8Name.constData();
+
+ int d0Idx = (context == component)?-1:context->metaObject()->indexOfProperty(cname);
+ int d1Idx = -1;
+ if (d0Idx == -1)
+ d1Idx = component->metaObject()->indexOfProperty(cname);
+
+ if (d0Idx != -1) {
+ Instr instr;
+ instr.type = Instr::LoadScope;
+ instr.load.index = 0;
+ instr.load.reg = reg;
+ bytecode << instr;
+
+ subscribeName << QLatin1String("$$$Scope");
+ subscribeName << name;
+
+ type = fetch(context->metaObject(), reg, d0Idx, subscribeName);
+ } else if(d1Idx != -1) {
+ Instr instr;
+ instr.type = Instr::LoadRoot;
+ instr.load.index = 0;
+ instr.load.reg = reg;
+ bytecode << instr;
+
+ subscribeName << QLatin1String("$$$Root");
+ subscribeName << name;
+
+ type = fetch(component->metaObject(), reg, d1Idx, subscribeName);
+ } else {
+ Instr find;
+ if (nameParts.count() == 1)
+ find.type = Instr::FindGenericTerminal;
+ else
+ find.type = Instr::FindGeneric;
+
+ find.find.reg = reg;
+ find.find.src = -1;
+ find.find.typeReg = 2; // XXX
+ find.find.name = registerString(name);
+
+ subscribeName << QString(QLatin1String("$$$Generic_") + name);
+ if (subscription(subscribeName))
+ find.find.subscribeIndex = subscriptionSet.count() - 1;
+ else
+ find.find.subscribeIndex = -1;
+
+ bytecode << find;
+ type.unknownType = true;
+ }
+
+ if (!type.unknownType && type.type == -1)
+ return false; // Couldn't fetch that type
+ }
+
+ } else {
+
+ const QMetaObject *mo = 0;
+ if (absType)
+ mo = absType->metaObject();
+ else if (type.metaObject)
+ mo = type.metaObject;
+
+ QByteArray utf8Name = name.toUtf8();
+ const char *cname = utf8Name.constData();
+ int idx = mo?mo->indexOfProperty(cname):-1;
+ if (absType && idx == -1)
+ return false;
+
+ subscribeName << name;
+
+ if (absType || (mo && mo->property(idx).isFinal())) {
+ absType = 0;
+ type = fetch(mo, reg, idx, subscribeName);
+ if (type.type == -1)
+ return false;
+ } else {
+
+ Instr prop;
+ if (ii == nameParts.count() -1 )
+ prop.type = Instr::FindPropertyTerminal;
+ else
+ prop.type = Instr::FindProperty;
+
+ prop.find.reg = reg;
+ prop.find.src = reg;
+ prop.find.typeReg = 2; // XXX
+ prop.find.name = registerString(name);
+ if (subscription(subscribeName))
+ prop.find.subscribeIndex = subscriptionSet.count() - 1;
+ else
+ prop.find.subscribeIndex = -1;
+
+ type.unknownType = true;
+ type.metaObject = 0;
+ type.type = -1;
+ type.reg = reg;
+ bytecode << prop;
+ }
+ }
+ }
+
+ return true;
+}
+
+bool QmlBindingCompiler::tryArith(QmlJS::AST::Node *node)
+{
+ if (node->kind != AST::Node::Kind_BinaryExpression)
+ return false;
+
+ AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);
+ if (expression->op == QSOperator::Add ||
+ expression->op == QSOperator::Sub)
+ return true;
+ else
+ return false;
+}
+
+bool QmlBindingCompiler::parseArith(QmlJS::AST::Node *node, Result &type)
+{
+ AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);
+
+ Result lhs;
+ Result rhs;
+
+ if (!parseExpression(expression->left, lhs)) return false;
+ if (!parseExpression(expression->right, rhs)) return false;
+
+ if (lhs.type != QVariant::Int &
+ lhs.type != QMetaType::QReal)
+ return false;
+
+ if (rhs.type != QVariant::Int &
+ rhs.type != QMetaType::QReal)
+ return false;
+
+ bool nativeReal = rhs.type == QMetaType::QReal ||
+ lhs.type == QMetaType::QReal;
+
+
+ if (nativeReal && lhs.type == QMetaType::Int) {
+ Instr convert;
+ convert.type = Instr::ConvertIntToReal;
+ convert.unaryop.output = lhs.reg;
+ convert.unaryop.src = lhs.reg;
+ bytecode << convert;
+ }
+
+ if (nativeReal && rhs.type == QMetaType::Int) {
+ Instr convert;
+ convert.type = Instr::ConvertIntToReal;
+ convert.unaryop.output = rhs.reg;
+ convert.unaryop.src = rhs.reg;
+ bytecode << convert;
+ }
+
+ Instr arith;
+ if (expression->op == QSOperator::Add) {
+ arith.type = nativeReal?Instr::AddReal:Instr::AddInt;
+ } else if (expression->op == QSOperator::Sub) {
+ arith.type = nativeReal?Instr::MinusReal:Instr::MinusInt;
+ } else {
+ qFatal("Unsupported arithmetic operator");
+ }
+
+ // We release early so we can reuse one of the registers as
+ // the output
+ releaseReg(lhs.reg);
+ releaseReg(rhs.reg);
+
+ type.reg = acquireReg();
+
+ arith.binaryop.output = type.reg;
+ arith.binaryop.src1 = lhs.reg;
+ arith.binaryop.src2 = rhs.reg;
+ bytecode << arith;
+
+ type.metaObject = 0;
+ type.type = nativeReal?QMetaType::QReal:QMetaType::Int;
+
+ return true;
+}
+
+bool QmlBindingCompiler::tryLogic(QmlJS::AST::Node *node)
+{
+ if (node->kind != AST::Node::Kind_BinaryExpression)
+ return false;
+
+ AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);
+ if (expression->op == QSOperator::Gt)
+ return true;
+ else
+ return false;
+}
+
+bool QmlBindingCompiler::parseLogic(QmlJS::AST::Node *node, Result &type)
+{
+ AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);
+
+ Result lhs;
+ Result rhs;
+
+ if (!parseExpression(expression->left, lhs)) return false;
+ if (!parseExpression(expression->right, rhs)) return false;
+
+ if (lhs.type != QMetaType::QReal || rhs.type != QMetaType::QReal)
+ return false;
+
+ // We release early so we can reuse one of the registers as
+ // the output
+ releaseReg(lhs.reg);
+ releaseReg(rhs.reg);
+
+ type.reg = acquireReg();
+ type.metaObject = 0;
+ type.type = QVariant::Bool;
+
+ Instr op;
+ op.type = Instr::GreaterThanReal;
+ op.binaryop.output = type.reg;
+ op.binaryop.src1 = lhs.reg;
+ op.binaryop.src2 = rhs.reg;
+ bytecode << op;
+
+ return true;
+}
+
+bool QmlBindingCompiler::tryConditional(QmlJS::AST::Node *node)
+{
+ return (node->kind == AST::Node::Kind_ConditionalExpression);
+}
+
+bool QmlBindingCompiler::parseConditional(QmlJS::AST::Node *node, Result &type)
+{
+ AST::ConditionalExpression *expression = static_cast<AST::ConditionalExpression *>(node);
+
+ AST::Node *test = expression->expression;
+ if (test->kind == AST::Node::Kind_NestedExpression)
+ test = static_cast<AST::NestedExpression*>(test)->expression;
+
+ Result etype;
+ if (!parseExpression(test, etype)) return false;
+
+ if (etype.type != QVariant::Bool)
+ return false;
+
+ Instr skip;
+ skip.type = Instr::Skip;
+ skip.skip.reg = etype.reg;
+ skip.skip.count = 0;
+ int skipIdx = bytecode.count();
+ bytecode << skip;
+
+ // Release to allow reuse of reg
+ releaseReg(etype.reg);
+
+ int preConditionalSubscriptions = subscriptionSet.count();
+
+ Result ok;
+ if (!parseExpression(expression->ok, ok)) return false;
+ if (ok.unknownType) return false;
+
+ int skipIdx2 = bytecode.count();
+ skip.skip.reg = -1;
+ bytecode << skip;
+
+ // Release to allow reuse of reg
+ releaseReg(ok.reg);
+ bytecode[skipIdx].skip.count = bytecode.count() - skipIdx - 1;
+
+ Result ko;
+ if (!parseExpression(expression->ko, ko)) return false;
+ if (ko.unknownType) return false;
+
+ // Release to allow reuse of reg
+ releaseReg(ko.reg);
+ bytecode[skipIdx2].skip.count = bytecode.count() - skipIdx2 - 1;
+
+ if (ok != ko)
+ return false; // Must be same type and in same register
+
+ if (preConditionalSubscriptions != subscriptionSet.count())
+ return false; // Conditionals cannot introduce new subscriptions
+
+ type = ok;
+
+ return true;
+}
+
+bool QmlBindingCompiler::tryConstant(QmlJS::AST::Node *node)
+{
+ return node->kind == AST::Node::Kind_TrueLiteral ||
+ node->kind == AST::Node::Kind_FalseLiteral ||
+ node->kind == AST::Node::Kind_NumericLiteral;
+}
+
+bool QmlBindingCompiler::parseConstant(QmlJS::AST::Node *node, Result &type)
+{
+ type.metaObject = 0;
+ type.type = -1;
+ type.reg = acquireReg();
+
+ if (node->kind == AST::Node::Kind_TrueLiteral) {
+ type.type = QVariant::Bool;
+ Instr instr;
+ instr.type = Instr::Bool;
+ instr.bool_value.reg = type.reg;
+ instr.bool_value.value = true;
+ bytecode << instr;
+ return true;
+ } else if (node->kind == AST::Node::Kind_FalseLiteral) {
+ type.type = QVariant::Bool;
+ Instr instr;
+ instr.type = Instr::Bool;
+ instr.bool_value.reg = type.reg;
+ instr.bool_value.value = false;
+ bytecode << instr;
+ return true;
+ } else if (node->kind == AST::Node::Kind_NumericLiteral) {
+ type.type = QMetaType::QReal;
+ Instr instr;
+ instr.type = Instr::Real;
+ instr.real_value.reg = type.reg;
+ instr.real_value.value = qreal(static_cast<AST::NumericLiteral *>(node)->value);
+ bytecode << instr;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool QmlBindingCompiler::buildName(QStringList &name,
+ QmlJS::AST::Node *node)
+{
+ if (node->kind == AST::Node::Kind_IdentifierExpression) {
+ name << static_cast<AST::IdentifierExpression*>(node)->name->asString();
+ } else if (node->kind == AST::Node::Kind_FieldMemberExpression) {
+ AST::FieldMemberExpression *expr =
+ static_cast<AST::FieldMemberExpression *>(node);
+
+ if (!buildName(name, expr->base))
+ return false;
+
+ name << expr->name->asString();
+ } else {
+ return false;
+ }
+
+ return true;
+}
+
+QmlBindingCompiler::Result
+QmlBindingCompiler::fetch(const QMetaObject *mo, int reg, int idx, const QStringList &subName)
+{
+ QMetaProperty prop = mo->property(idx);
+ if (subscription(subName) && prop.hasNotifySignal() && prop.notifySignalIndex() != -1) {
+ Instr sub;
+ sub.type = Instr::Subscribe;
+ sub.subscribe.offset = subscriptionSet.count() - 1;
+ sub.subscribe.reg = reg;
+ sub.subscribe.index = prop.notifySignalIndex();
+ bytecode << sub;
+ }
+
+ Instr instr;
+ instr.type = Instr::Fetch;
+ instr.fetch.objectReg = reg;
+ instr.fetch.index = idx;
+ instr.fetch.output = reg;
+ bytecode << instr;
+
+ Result rv;
+ rv.type = prop.userType();
+ rv.metaObject = QmlMetaType::metaObjectForType(rv.type);
+ rv.reg = reg;
+
+ if (!rv.metaObject &&
+ rv.type != QMetaType::QReal &&
+ rv.type != QMetaType::Int &&
+ rv.type != QMetaType::Bool &&
+ rv.type != qMetaTypeId<QmlGraphicsAnchorLine>())
+ return Result(); // Unsupported type (string not supported yet);
+
+ return rv;
+}
+
+int QmlBindingCompiler::acquireReg()
+{
+ for (int ii = 0; ii < 32; ++ii) {
+ if (!(registers & (1 << ii))) {
+ registers |= (1 << ii);
+ return ii;
+ }
+ }
+ return -1;
+}
+
+void QmlBindingCompiler::releaseReg(int reg)
+{
+ Q_ASSERT(reg >= 0 && reg <= 31);
+
+ quint32 mask = 1 << reg;
+ registers &= ~mask;
+}
+
+int QmlBindingCompiler::registerString(const QString &string)
+{
+ Q_ASSERT(!string.isEmpty());
+
+ // ### Padding?
+ QByteArray strdata((const char *)string.constData(), string.length() * sizeof(QChar));
+ int rv = data.count();
+ data += strdata;
+
+ Instr reg;
+ reg.type = Instr::InitString;
+ reg.initstring.offset = strings++;
+ reg.initstring.dataIdx = rv;
+ reg.initstring.length = string.length();
+ bytecode << reg;
+
+ return strings - 1;
+}
+
+bool QmlBindingCompiler::subscription(const QStringList &sub)
+{
+ QString str = sub.join(QLatin1String("."));
+
+ if (subscriptionSet.contains(str)) {
+ return false;
+ } else {
+ subscriptionSet.insert(str);
+ return true;
+ }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/declarative/qml/qmlbindingvme_p.h b/src/declarative/qml/qmlbindingvme_p.h
new file mode 100644
index 0000000..9a0239d
--- /dev/null
+++ b/src/declarative/qml/qmlbindingvme_p.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLBINDINGVME_P_H
+#define QMLBINDINGVME_P_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qglobal.h>
+#include <private/qmlbasicscript_p.h>
+#include <private/qscriptdeclarativeclass_p.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QObject;
+class QmlContextPrivate;
+class QmlBindingVME
+{
+public:
+ struct Config {
+ Config() : target(0), targetSlot(-1), subscriptions(0), identifiers(0) {}
+ ~Config() { delete [] subscriptions; delete [] identifiers; }
+ QObject *target;
+ int targetSlot;
+
+ struct Subscription {
+ QGuard<QObject> source;
+ int notifyIndex;
+ };
+ Subscription *subscriptions;
+ QScriptDeclarativeClass::PersistentIdentifier *identifiers;
+ };
+
+ static QByteArray compile(const QmlBasicScript::Expression &);
+ static void run(const char *program,
+ Config *config, QmlContextPrivate *context,
+ QObject **scopes, QObject **outputs);
+ static void dump(const QByteArray &);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QMLBINDINGVME_P_H
+
diff --git a/src/declarative/qml/qmlcompiler.cpp b/src/declarative/qml/qmlcompiler.cpp
index f9a9b1b..fa7da95 100644
--- a/src/declarative/qml/qmlcompiler.cpp
+++ b/src/declarative/qml/qmlcompiler.cpp
@@ -64,9 +64,12 @@
#include "qmlscriptstring.h"
#include "qmlglobal_p.h"
#include "qmlscriptparser_p.h"
+#include "qmlbinding.h"
+#include "qmlbindingvme_p.h"
#include <qfxperf_p_p.h>
+#include <QCoreApplication>
#include <QColor>
#include <QDebug>
#include <QPointF>
@@ -74,12 +77,12 @@
#include <QRectF>
#include <QAtomicInt>
#include <QtCore/qdebug.h>
-#include <QCoreApplication>
QT_BEGIN_NAMESPACE
DEFINE_BOOL_CONFIG_OPTION(compilerDump, QML_COMPILER_DUMP);
DEFINE_BOOL_CONFIG_OPTION(compilerStatDump, QML_COMPILER_STATISTICS_DUMP);
+DEFINE_BOOL_CONFIG_OPTION(qmlExperimental, QML_EXPERIMENTAL);
using namespace QmlParser;
@@ -2417,11 +2420,27 @@ void QmlCompiler::genBindingAssignment(QmlParser::Value *binding,
Q_ASSERT(compileState.bindings.contains(binding));
const BindingReference &ref = compileState.bindings.value(binding);
+ if (ref.dataType == BindingReference::Experimental) {
+ QmlInstruction store;
+ store.type = QmlInstruction::StoreCompiledBinding;
+ store.assignBinding.value = output->indexForByteArray(ref.compiledData);
+ store.assignBinding.context = ref.bindingContext.stack;
+ store.assignBinding.owner = ref.bindingContext.owner;
+ if (valueTypeProperty)
+ store.assignBinding.property = (valueTypeProperty->index & 0xFFFF) |
+ ((valueTypeProperty->type & 0xFF)) << 16 |
+ ((prop->index & 0xFF) << 24);
+ else
+ store.assignBinding.property = prop->index;
+ store.line = binding->location.start.line;
+ output->bytecode << store;
+ return;
+ }
QmlInstruction store;
QmlBasicScript bs;
- if (ref.isBasicScript)
+ if (ref.dataType == BindingReference::BasicScript)
bs.load(ref.compiledData.constData() + sizeof(quint32));
if (bs.isSingleIdFetch()) {
@@ -2519,16 +2538,31 @@ bool QmlCompiler::completeComponentBuild()
expr.expression = binding.expression;
bs.compile(expr);
+
+ if (qmlExperimental() && (!bs.isValid() || (!bs.isSingleIdFetch() && !bs.isSingleContextProperty()))) {
+
+ QByteArray qmvdata = QmlBindingVME::compile(expr);
+ if (!qmvdata.isEmpty()) {
+ qWarning() << expr.expression.asScript();
+ QmlBindingVME::dump(qmvdata);
+ binding.dataType = BindingReference::Experimental;
+ binding.compiledData = qmvdata;
+ componentStat.optimizedBindings++;
+ continue;
+ }
+ }
+
quint32 type;
if (bs.isValid()) {
binding.compiledData =
QByteArray(bs.compileData(), bs.compileDataSize());
type = QmlExpressionPrivate::BasicScriptEngineData;
- binding.isBasicScript = true;
+ binding.dataType = BindingReference::BasicScript;
componentStat.optimizedBindings++;
} else {
type = QmlExpressionPrivate::PreTransformedQtScriptData;
+ binding.dataType = BindingReference::QtScript;
// Pre-rewrite the expression
QString expression = binding.expression.asScript();
@@ -2557,7 +2591,6 @@ bool QmlCompiler::completeComponentBuild()
QByteArray((const char *)&length, sizeof(quint32)) +
QByteArray((const char *)expression.constData(),
expression.length() * sizeof(QChar));
- binding.isBasicScript = false;
componentStat.scriptBindings++;
}
diff --git a/src/declarative/qml/qmlcompiler_p.h b/src/declarative/qml/qmlcompiler_p.h
index 809cc72..d734a12 100644
--- a/src/declarative/qml/qmlcompiler_p.h
+++ b/src/declarative/qml/qmlcompiler_p.h
@@ -269,7 +269,10 @@ private:
QmlParser::Variant expression;
QmlParser::Property *property;
QmlParser::Value *value;
- bool isBasicScript;
+
+ enum DataType { QtScript, BasicScript, Experimental };
+ DataType dataType;
+
QByteArray compiledData;
BindingContext bindingContext;
};
diff --git a/src/declarative/qml/qmlcontext_p.h b/src/declarative/qml/qmlcontext_p.h
index 0229056..35971d9 100644
--- a/src/declarative/qml/qmlcontext_p.h
+++ b/src/declarative/qml/qmlcontext_p.h
@@ -130,7 +130,9 @@ public:
static QmlContextPrivate *get(QmlContext *context) {
return static_cast<QmlContextPrivate *>(QObjectPrivate::get(context));
}
-
+ static QmlContext *get(QmlContextPrivate *context) {
+ return static_cast<QmlContext *>(context->q_func());
+ }
// Only used for debugging
QList<QPointer<QObject> > instances;
};
diff --git a/src/declarative/qml/qmlinstruction.cpp b/src/declarative/qml/qmlinstruction.cpp
index 010010d..67db9c6 100644
--- a/src/declarative/qml/qmlinstruction.cpp
+++ b/src/declarative/qml/qmlinstruction.cpp
@@ -156,6 +156,9 @@ void QmlCompiledData::dump(QmlInstruction *instr, int idx)
break;
case QmlInstruction::StoreBinding:
+ qWarning().nospace() << idx << "\t\t" << line << "\t" << "STORE_BINDING\t" << instr->assignBinding.property << "\t" << instr->assignBinding.value << "\t" << instr->assignBinding.context;
+ break;
+ case QmlInstruction::StoreCompiledBinding:
qWarning().nospace() << idx << "\t\t" << line << "\t" << "STORE_COMPILED_BINDING\t" << instr->assignBinding.property << "\t" << instr->assignBinding.value << "\t" << instr->assignBinding.context;
break;
case QmlInstruction::StoreIdOptBinding:
diff --git a/src/declarative/qml/qmlinstruction_p.h b/src/declarative/qml/qmlinstruction_p.h
index a5fc40c..d06ac86 100644
--- a/src/declarative/qml/qmlinstruction_p.h
+++ b/src/declarative/qml/qmlinstruction_p.h
@@ -128,6 +128,7 @@ public:
AssignCustomType, /* assignCustomType */
StoreBinding, /* assignBinding */
+ StoreCompiledBinding, /* assignBinding */
StoreIdOptBinding, /* assignIdOptBinding */
StoreObjPropBinding, /* assignObjPropBinding */
StoreValueSource, /* assignValueSource */
@@ -196,7 +197,7 @@ public:
int castValue;
} assignValueInterceptor;
struct {
- int property;
+ unsigned int property;
int value;
short context;
short owner;
diff --git a/src/declarative/qml/qmlvme.cpp b/src/declarative/qml/qmlvme.cpp
index e3fc288..e4295a1 100644
--- a/src/declarative/qml/qmlvme.cpp
+++ b/src/declarative/qml/qmlvme.cpp
@@ -608,6 +608,27 @@ QObject *QmlVME::run(QmlVMEStack<QObject *> &stack, QmlContext *ctxt,
}
break;
+ case QmlInstruction::StoreCompiledBinding:
+ {
+ QObject *target =
+ stack.at(stack.count() - 1 - instr.assignBinding.owner);
+ QObject *scope =
+ stack.at(stack.count() - 1 - instr.assignBinding.context);
+
+ int property = instr.assignBinding.property;
+ if (stack.count() == 1 && bindingSkipList.testBit(property & 0xFFFF))
+ break;
+
+ const char *data = datas.at(instr.assignBinding.value).constData();
+
+ QmlBinding_Basic *bind =
+ new QmlBinding_Basic(target, property, data, comp, scope, ctxt);
+ bindValues.append(bind);
+ bind->m_mePtr = &bindValues.values[bindValues.count - 1];
+ bind->addToObject(target);
+ }
+ break;
+
case QmlInstruction::StoreIdOptBinding:
{
int coreIndex = instr.assignIdOptBinding.property;
generated by cgit v0.12 at 2024-12-04 04:33:40 (GMT)