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 QtDeclarative module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

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

    41 

    42 // #define COMPILEDBINDINGS_DEBUG

    43 

    44 #include "private/qdeclarativecompiledbindings_p.h"

    45 

    46 #include <QtDeclarative/qdeclarativeinfo.h>

    47 #include <private/qdeclarativecontext_p.h>

    48 #include <private/qdeclarativejsast_p.h>

    49 #include <private/qdeclarativejsengine_p.h>

    50 #include <private/qdeclarativeexpression_p.h>

    51 #include <QtCore/qcoreapplication.h>

    52 #include <QtCore/qdebug.h>

    53 #include <QtCore/qnumeric.h>

    54 #include <private/qdeclarativeanchors_p_p.h>

    55 #include <private/qdeclarativeglobal_p.h>

    56 #include <private/qdeclarativefastproperties_p.h>

    57 

    58 QT_BEGIN_NAMESPACE

    59 

    60 DEFINE_BOOL_CONFIG_OPTION(qmlExperimental, QML_EXPERIMENTAL);

    61 DEFINE_BOOL_CONFIG_OPTION(qmlDisableOptimizer, QML_DISABLE_OPTIMIZER);

    62 DEFINE_BOOL_CONFIG_OPTION(qmlDisableFastProperties, QML_DISABLE_FAST_PROPERTIES);

    63 DEFINE_BOOL_CONFIG_OPTION(bindingsDump, QML_BINDINGS_DUMP);

    64 

    65 Q_GLOBAL_STATIC(QDeclarativeFastProperties, fastProperties);

    66 

    67 #ifdef __GNUC__

    68 #  define QML_THREADED_INTERPRETER

    69 #endif

    70 

    71 #define FOR_EACH_QML_INSTR(F) \

    72     F(Noop)                    /* Nop */ \

    73     F(BindingId)               /* id */ \

    74     F(Subscribe)               /* subscribe */ \

    75     F(SubscribeId)             /* subscribe */ \

    76     F(FetchAndSubscribe)       /* fetchAndSubscribe */ \

    77     F(LoadId)                  /* load */ \

    78     F(LoadScope)               /* load */ \

    79     F(LoadRoot)                /* load */ \

    80     F(LoadAttached)            /* attached */ \

    81     F(ConvertIntToReal)        /* unaryop */ \

    82     F(ConvertRealToInt)        /* unaryop */ \

    83     F(Real)                    /* real_value */ \

    84     F(Int)                     /* int_value */ \

    85     F(Bool)                    /* bool_value */ \

    86     F(String)                  /* string_value */ \

    87     F(AddReal)                 /* binaryop */ \

    88     F(AddInt)                  /* binaryop */ \

    89     F(AddString)               /* binaryop */ \

    90     F(MinusReal)               /* binaryop */ \

    91     F(MinusInt)                /* binaryop */ \

    92     F(CompareReal)             /* binaryop */ \

    93     F(CompareString)           /* binaryop */ \

    94     F(NotCompareReal)          /* binaryop */ \

    95     F(NotCompareString)        /* binaryop */ \

    96     F(GreaterThanReal)         /* binaryop */ \

    97     F(MaxReal)                 /* binaryop */ \

    98     F(MinReal)                 /* binaryop */ \

    99     F(NewString)               /* construct */ \

   100     F(NewUrl)                  /* construct */ \

   101     F(CleanupUrl)              /* cleanup */ \

   102     F(CleanupString)           /* cleanup */ \

   103     F(Copy)                    /* copy */ \

   104     F(Fetch)                   /* fetch */ \

   105     F(Store)                   /* store */ \

   106     F(Skip)                    /* skip */ \

   107     F(Done)                    /* done */ \

   108     /* Speculative property resolution */ \

   109     F(InitString)              /* initstring */ \

   110     F(FindGeneric)             /* find */ \

   111     F(FindGenericTerminal)     /* find */ \

   112     F(FindProperty)            /* find */ \

   113     F(FindPropertyTerminal)    /* find */ \

   114     F(CleanupGeneric)          /* cleanup */ \

   115     F(ConvertGenericToReal)    /* unaryop */ \

   116     F(ConvertGenericToBool)    /* unaryop */ \

   117     F(ConvertGenericToString)  /* unaryop */ \

   118     F(ConvertGenericToUrl)     /* unaryop */

   119 

   120 #define QML_INSTR_ENUM(I) I,

   121 #define QML_INSTR_ADDR(I) &&op_##I,

   122 

   123 #ifdef QML_THREADED_INTERPRETER

   124 #  define QML_BEGIN_INSTR(I) op_##I:

   125 #  define QML_END_INSTR(I) ++instr; goto *instr->common.code;

   126 #  define QML_INSTR_HEADER void *code;

   127 #else

   128 #  define QML_BEGIN_INSTR(I) case Instr::I:

   129 #  define QML_END_INSTR(I) break;

   130 #  define QML_INSTR_HEADER

   131 #endif

   132 

   133 

   134 using namespace QDeclarativeJS;

   135 

   136 namespace {

   137 // Supported types: int, qreal, QString (needs constr/destr), QObject*, bool

   138 struct Register {

   139     void setUndefined() { type = 0; }

   140     void setUnknownButDefined() { type = -1; }

   141     void setNaN() { setqreal(qSNaN()); }

   142     bool isUndefined() const { return type == 0; }

   143 

   144     void setQObject(QObject *o) { *((QObject **)data) = o; type = QMetaType::QObjectStar; }

   145     QObject *getQObject() const { return *((QObject **)data); }

   146 

   147     void setqreal(qreal v) { *((qreal *)data) = v; type = QMetaType::QReal; }

   148     qreal getqreal() const { return *((qreal *)data); }

   149 

   150     void setint(int v) { *((int *)data) = v; type = QMetaType::Int; }

   151     int getint() const { return *((int *)data); }

   152 

   153     void setbool(bool v) { *((bool *)data) = v; type = QMetaType::Bool; }

   154     bool getbool() const { return *((bool *)data); }

   155 

   156     QVariant *getvariantptr() { return (QVariant *)typeDataPtr(); }

   157     QString *getstringptr() { return (QString *)typeDataPtr(); }

   158     QUrl *geturlptr() { return (QUrl *)typeDataPtr(); }

   159     const QVariant *getvariantptr() const { return (QVariant *)typeDataPtr(); }

   160     const QString *getstringptr() const { return (QString *)typeDataPtr(); }

   161     const QUrl *geturlptr() const { return (QUrl *)typeDataPtr(); }

   162 

   163     void *typeDataPtr() { return (void *)&data; }

   164     void *typeMemory() { return (void *)data; }

   165     const void *typeDataPtr() const { return (void *)&data; }

   166     const void *typeMemory() const { return (void *)data; }

   167 

   168     int gettype() const { return type; }

   169     void settype(int t) { type = t; }

   170 

   171     int type;          // Optional type

   172     void *data[2];     // Object stored here

   173 };

   174 }

   175 

   176 class QDeclarativeCompiledBindingsPrivate : public QObjectPrivate

   177 {

   178     Q_DECLARE_PUBLIC(QDeclarativeCompiledBindings)

   179 

   180 public:

   181     QDeclarativeCompiledBindingsPrivate();

   182     virtual ~QDeclarativeCompiledBindingsPrivate();

   183 

   184     struct Binding : public QDeclarativeAbstractBinding, public QDeclarativeDelayedError {

   185         Binding() : enabled(false), updating(0), property(0),

   186                     scope(0), target(0), parent(0) {}

   187 

   188         // Inherited from QDeclarativeAbstractBinding

   189         virtual void setEnabled(bool, QDeclarativePropertyPrivate::WriteFlags flags);

   190         virtual int propertyIndex();

   191         virtual void update(QDeclarativePropertyPrivate::WriteFlags flags);

   192         virtual void destroy();

   193 

   194         int index:30;

   195         bool enabled:1;

   196         bool updating:1;

   197         int property;

   198         QObject *scope;

   199         QObject *target;

   200 

   201         QDeclarativeCompiledBindingsPrivate *parent;

   202     };

   203 

   204     typedef QDeclarativeNotifierEndpoint Subscription;

   205     Subscription *subscriptions;

   206     QScriptDeclarativeClass::PersistentIdentifier *identifiers;

   207 

   208     void run(Binding *, QDeclarativePropertyPrivate::WriteFlags flags);

   209 

   210     const char *programData;

   211     Binding *m_bindings;

   212     quint32 *m_signalTable;

   213 

   214     static int methodCount;

   215 

   216     void init();

   217     void run(int instr, QDeclarativeContextData *context, 

   218              QDeclarativeDelayedError *error, QObject *scope, QObject *output, QDeclarativePropertyPrivate::WriteFlags storeFlags);

   219 

   220 

   221     inline void unsubscribe(int subIndex);

   222     inline void subscribeId(QDeclarativeContextData *p, int idIndex, int subIndex);

   223     inline void subscribe(QObject *o, int notifyIndex, int subIndex);

   224 

   225     QDeclarativePropertyCache::Data *findproperty(QObject *obj, 

   226                                                   const QScriptDeclarativeClass::Identifier &name,

   227                                                   QDeclarativeEnginePrivate *enginePriv, 

   228                                                   QDeclarativePropertyCache::Data &local);

   229     bool findproperty(QObject *obj, 

   230                       Register *output, 

   231                       QDeclarativeEnginePrivate *enginePriv,

   232                       int subIdx, 

   233                       const QScriptDeclarativeClass::Identifier &name,

   234                       bool isTerminal);

   235     void findgeneric(Register *output,                                 // value output

   236                      int subIdx,                                       // Subscription index in config

   237                      QDeclarativeContextData *context,                 // Context to search in

   238                      const QScriptDeclarativeClass::Identifier &name, 

   239                      bool isTerminal);

   240 };

   241 

   242 QDeclarativeCompiledBindingsPrivate::QDeclarativeCompiledBindingsPrivate()

   243 : subscriptions(0), identifiers(0)

   244 {

   245 }

   246 

   247 QDeclarativeCompiledBindingsPrivate::~QDeclarativeCompiledBindingsPrivate()

   248 {

   249     delete [] subscriptions; subscriptions = 0;

   250     delete [] identifiers; identifiers = 0;

   251 }

   252 

   253 int QDeclarativeCompiledBindingsPrivate::methodCount = -1;

   254 

   255 QDeclarativeCompiledBindings::QDeclarativeCompiledBindings(const char *program, QDeclarativeContextData *context)

   256 : QObject(*(new QDeclarativeCompiledBindingsPrivate))

   257 {

   258     Q_D(QDeclarativeCompiledBindings);

   259 

   260     if (d->methodCount == -1)

   261         d->methodCount = QDeclarativeCompiledBindings::staticMetaObject.methodCount();

   262 

   263     d->programData = program;

   264 

   265     d->init();

   266 

   267     QDeclarativeAbstractExpression::setContext(context);

   268 }

   269 

   270 QDeclarativeCompiledBindings::~QDeclarativeCompiledBindings()

   271 {

   272     Q_D(QDeclarativeCompiledBindings);

   273 

   274     delete [] d->m_bindings;

   275 }

   276 

   277 QDeclarativeAbstractBinding *QDeclarativeCompiledBindings::configBinding(int index, QObject *target, 

   278                                                         QObject *scope, int property)

   279 {

   280     Q_D(QDeclarativeCompiledBindings);

   281 

   282     QDeclarativeCompiledBindingsPrivate::Binding *rv = d->m_bindings + index;

   283 

   284     rv->index = index;

   285     rv->property = property;

   286     rv->target = target;

   287     rv->scope = scope;

   288     rv->parent = d;

   289 

   290     addref(); // This is decremented in Binding::destroy()

   291 

   292     return rv;

   293 }

   294 

   295 void QDeclarativeCompiledBindingsPrivate::Binding::setEnabled(bool e, QDeclarativePropertyPrivate::WriteFlags flags)

   296 {

   297     if (e) {

   298         addToObject(target);

   299     } else {

   300         removeFromObject();

   301     }

   302 

   303     QDeclarativeAbstractBinding::setEnabled(e, flags);

   304 

   305     if (enabled != e) {

   306         enabled = e;

   307 

   308         if (e) update(flags);

   309     }

   310 }

   311 

   312 int QDeclarativeCompiledBindingsPrivate::Binding::propertyIndex()

   313 {

   314     return property & 0xFFFF;

   315 }

   316 

   317 void QDeclarativeCompiledBindingsPrivate::Binding::update(QDeclarativePropertyPrivate::WriteFlags flags)

   318 {

   319     parent->run(this, flags);

   320 }

   321 

   322 void QDeclarativeCompiledBindingsPrivate::Binding::destroy()

   323 {

   324     enabled = false;

   325     removeFromObject();

   326     clear();

   327     parent->q_func()->release();

   328 }

   329 

   330 int QDeclarativeCompiledBindings::qt_metacall(QMetaObject::Call c, int id, void **)

   331 {

   332     Q_D(QDeclarativeCompiledBindings);

   333 

   334     if (c == QMetaObject::InvokeMetaMethod && id >= d->methodCount) {

   335         id -= d->methodCount;

   336 

   337         quint32 *reeval = d->m_signalTable + d->m_signalTable[id];

   338         quint32 count = *reeval;

   339         ++reeval;

   340         for (quint32 ii = 0; ii < count; ++ii) {

   341             d->run(d->m_bindings + reeval[ii], QDeclarativePropertyPrivate::DontRemoveBinding);

   342         }

   343     }

   344     return -1;

   345 }

   346 

   347 void QDeclarativeCompiledBindingsPrivate::run(Binding *binding, QDeclarativePropertyPrivate::WriteFlags flags)

   348 {

   349     Q_Q(QDeclarativeCompiledBindings);

   350 

   351     if (!binding->enabled)

   352         return;

   353 

   354     QDeclarativeContextData *context = q->QDeclarativeAbstractExpression::context();

   355     if (!context || !context->isValid()) 

   356         return;

   357 

   358     if (binding->updating) {

   359         QString name;

   360         if (binding->property & 0xFFFF0000) {

   361             QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context->engine);

   362 

   363             QDeclarativeValueType *vt = ep->valueTypes[(binding->property >> 16) & 0xFF];

   364             Q_ASSERT(vt);

   365 

   366             name = QLatin1String(binding->target->metaObject()->property(binding->property & 0xFFFF).name());

   367             name.append(QLatin1String("."));

   368             name.append(QLatin1String(vt->metaObject()->property(binding->property >> 24).name()));

   369         } else {

   370             name = QLatin1String(binding->target->metaObject()->property(binding->property).name());

   371         }

   372         qmlInfo(binding->target) << QCoreApplication::translate("QDeclarativeCompiledBindings", "Binding loop detected for property \"%1\"").arg(name);

   373         return;

   374     }

   375 

   376     binding->updating = true;

   377     if (binding->property & 0xFFFF0000) {

   378         QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context->engine);

   379 

   380         QDeclarativeValueType *vt = ep->valueTypes[(binding->property >> 16) & 0xFF];

   381         Q_ASSERT(vt);

   382         vt->read(binding->target, binding->property & 0xFFFF);

   383 

   384         QObject *target = vt;

   385         run(binding->index, context, binding, binding->scope, target, flags);

   386 

   387         vt->write(binding->target, binding->property & 0xFFFF, flags);

   388     } else {

   389         run(binding->index, context, binding, binding->scope, binding->target, flags);

   390     }

   391     binding->updating = false;

   392 }

   393 

   394 namespace {

   395 // This structure is exactly 8-bytes in size

   396 struct Instr {

   397     enum {

   398         FOR_EACH_QML_INSTR(QML_INSTR_ENUM)

   399     };

   400 

   401     union {

   402         struct {

   403             QML_INSTR_HEADER

   404             quint8 type;

   405             quint8 packing[7];

   406         } common;

   407         struct {

   408             QML_INSTR_HEADER

   409             quint8 type;

   410             quint8 packing;

   411             quint16 column;

   412             quint32 line;

   413         } id;

   414         struct {

   415             QML_INSTR_HEADER

   416             quint8 type;

   417             quint8 packing[3];

   418             quint16 subscriptions;

   419             quint16 identifiers;

   420         } init;

   421         struct {

   422             QML_INSTR_HEADER

   423             quint8 type;

   424             qint8 reg;

   425             quint16 offset;

   426             quint32 index;

   427         } subscribe;

   428         struct {

   429             QML_INSTR_HEADER

   430             quint8 type;

   431             qint8 reg;

   432             quint8 packing[2];

   433             quint32 index;

   434         } load;

   435         struct {

   436             QML_INSTR_HEADER

   437             quint8 type;

   438             qint8 output;

   439             qint8 reg;

   440             quint8 exceptionId;

   441             quint32 index;

   442         } attached;

   443         struct {

   444             QML_INSTR_HEADER

   445             quint8 type;

   446             qint8 output;

   447             qint8 reg;

   448             quint8 exceptionId;

   449             quint32 index;

   450         } store;

   451         struct {

   452             QML_INSTR_HEADER

   453             quint8 type;

   454             qint8 output;

   455             qint8 objectReg;

   456             quint8 exceptionId;

   457             quint16 subscription;

   458             quint16 function;

   459         } fetchAndSubscribe;

   460         struct {

   461             QML_INSTR_HEADER

   462             quint8 type;

   463             qint8 output;

   464             qint8 objectReg;

   465             quint8 exceptionId;

   466             quint32 index;

   467         } fetch;

   468         struct {

   469             QML_INSTR_HEADER

   470             quint8 type;

   471             qint8 reg;

   472             qint8 src;

   473             quint8 packing[5];

   474         } copy;

   475         struct {

   476             QML_INSTR_HEADER

   477             quint8 type;

   478             qint8 reg;

   479             quint8 packing[6];

   480         } construct;

   481         struct {

   482             QML_INSTR_HEADER

   483             quint8 type;

   484             qint8 reg;

   485             quint8 packing[2];

   486             float value;

   487         } real_value;

   488         struct {

   489             QML_INSTR_HEADER

   490             quint8 type;

   491             qint8 reg;

   492             quint8 packing[2];

   493             int value;

   494         } int_value;

   495         struct {

   496             QML_INSTR_HEADER

   497             quint8 type;

   498             qint8 reg;

   499             bool value;

   500             quint8 packing[5];

   501         } bool_value;

   502         struct {

   503             QML_INSTR_HEADER

   504             quint8 type;

   505             qint8 reg;

   506             quint16 length;

   507             quint32 offset;

   508         } string_value;

   509         struct {

   510             QML_INSTR_HEADER

   511             quint8 type;

   512             qint8 output;

   513             qint8 src1;

   514             qint8 src2;

   515             quint8 packing[4];

   516         } binaryop;

   517         struct {

   518             QML_INSTR_HEADER

   519             quint8 type;

   520             qint8 output;

   521             qint8 src;

   522             quint8 packing[5];

   523         } unaryop;

   524         struct {

   525             QML_INSTR_HEADER

   526             quint8 type;

   527             qint8 reg;

   528             quint8 packing[2];

   529             quint32 count;

   530         } skip;

   531         struct {

   532             QML_INSTR_HEADER

   533             quint8 type;

   534             qint8 reg;

   535             qint8 src;

   536             quint8 exceptionId;

   537             quint16 name; 

   538             quint16 subscribeIndex;

   539         } find;

   540         struct {

   541             QML_INSTR_HEADER

   542             quint8 type;

   543             qint8 reg;

   544             quint8 packing[6];

   545         } cleanup;

   546         struct {

   547             QML_INSTR_HEADER

   548             quint8 type;

   549             quint8 packing[1];

   550             quint16 offset;

   551             quint32 dataIdx;

   552         } initstring;

   553     };

   554 };

   555 

   556 struct Program {

   557     quint32 bindings;

   558     quint32 dataLength;

   559     quint32 signalTableOffset;

   560     quint32 exceptionDataOffset;

   561     quint16 subscriptions;

   562     quint16 identifiers;

   563     quint16 instructionCount;

   564     quint16 compiled;

   565 

   566     const char *data() const { return ((const char *)this) + sizeof(Program); }

   567     const Instr *instructions() const { return (const Instr *)(data() + dataLength); }

   568 };

   569 }

   570 

   571 struct QDeclarativeBindingCompilerPrivate

   572 {

   573     struct Result {

   574         Result() : unknownType(false), metaObject(0), type(-1), reg(-1) {}

   575         bool operator==(const Result &o) const { 

   576             return unknownType == o.unknownType &&

   577                    metaObject == o.metaObject && 

   578                    type == o.type &&

   579                    reg == o.reg; 

   580         }

   581         bool operator!=(const Result &o) const { 

   582             return !(*this == o);

   583         }

   584         bool unknownType;

   585         const QMetaObject *metaObject;

   586         int type;

   587         int reg;

   588 

   589         QSet<QString> subscriptionSet;

   590     };

   591 

   592     QDeclarativeBindingCompilerPrivate() : registers(0) {}

   593 

   594     void resetInstanceState();

   595     int commitCompile();

   596 

   597     QDeclarativeParser::Object *context;

   598     QDeclarativeParser::Object *component;

   599     QDeclarativeParser::Property *destination;

   600     QHash<QString, QDeclarativeParser::Object *> ids;

   601     QDeclarativeImports imports;

   602     QDeclarativeEnginePrivate *engine;

   603 

   604     QString contextName() const { return QLatin1String("$$$SCOPE_") + QString::number((intptr_t)context, 16); }

   605 

   606     bool compile(QDeclarativeJS::AST::Node *);

   607 

   608     bool parseExpression(QDeclarativeJS::AST::Node *, Result &);

   609 

   610     bool tryName(QDeclarativeJS::AST::Node *);

   611     bool parseName(QDeclarativeJS::AST::Node *, Result &);

   612 

   613     bool tryArith(QDeclarativeJS::AST::Node *);

   614     bool parseArith(QDeclarativeJS::AST::Node *, Result &);

   615     bool numberArith(Result &, const Result &, const Result &, QSOperator::Op op);

   616     bool stringArith(Result &, const Result &, const Result &, QSOperator::Op op);

   617 

   618     bool tryLogic(QDeclarativeJS::AST::Node *);

   619     bool parseLogic(QDeclarativeJS::AST::Node *, Result &);

   620 

   621     bool tryConditional(QDeclarativeJS::AST::Node *);

   622     bool parseConditional(QDeclarativeJS::AST::Node *, Result &);

   623 

   624     bool tryConstant(QDeclarativeJS::AST::Node *);

   625     bool parseConstant(QDeclarativeJS::AST::Node *, Result &);

   626 

   627     bool tryMethod(QDeclarativeJS::AST::Node *);

   628     bool parseMethod(QDeclarativeJS::AST::Node *, Result &);

   629 

   630     bool buildName(QStringList &, QDeclarativeJS::AST::Node *, QList<QDeclarativeJS::AST::ExpressionNode *> *nodes = 0);

   631     bool fetch(Result &type, const QMetaObject *, int reg, int idx, const QStringList &, QDeclarativeJS::AST::ExpressionNode *);

   632 

   633     quint32 registers;

   634     QHash<int, QPair<int, int> > registerCleanups;

   635     int acquireReg(int cleanup = Instr::Noop, int cleanupType = 0);

   636     void registerCleanup(int reg, int cleanup, int cleanupType = 0);

   637     void releaseReg(int);

   638 

   639     int registerLiteralString(const QString &);

   640     int registerString(const QString &);

   641     QHash<QString, QPair<int, int> > registeredStrings;

   642     QByteArray data;

   643 

   644     bool subscription(const QStringList &, Result *);

   645     int subscriptionIndex(const QStringList &);

   646     bool subscriptionNeutral(const QSet<QString> &base, const QSet<QString> &lhs, const QSet<QString> &rhs);

   647 

   648     quint8 exceptionId(QDeclarativeJS::AST::ExpressionNode *);

   649     QVector<quint64> exceptions;

   650 

   651     QSet<int> usedSubscriptionIds;

   652     QSet<QString> subscriptionSet;

   653     QHash<QString, int> subscriptionIds;

   654     QVector<Instr> bytecode;

   655 

   656     // Committed binding data

   657     struct {

   658         QList<int> offsets;

   659         QList<QSet<int> > dependencies;

   660 

   661         QVector<Instr> bytecode;

   662         QByteArray data;

   663         QHash<QString, int> subscriptionIds;

   664         QVector<quint64> exceptions;

   665 

   666         QHash<QString, QPair<int, int> > registeredStrings;

   667 

   668         int count() const { return offsets.count(); }

   669     } committed;

   670 

   671     QByteArray buildSignalTable() const;

   672     QByteArray buildExceptionData() const;

   673 };

   674 

   675 void QDeclarativeCompiledBindingsPrivate::unsubscribe(int subIndex)

   676 {

   677     QDeclarativeCompiledBindingsPrivate::Subscription *sub = (subscriptions + subIndex);

   678     sub->disconnect();

   679 }

   680 

   681 void QDeclarativeCompiledBindingsPrivate::subscribeId(QDeclarativeContextData *p, int idIndex, int subIndex)

   682 {

   683     Q_Q(QDeclarativeCompiledBindings);

   684 

   685     unsubscribe(subIndex);

   686 

   687     if (p->idValues[idIndex]) {

   688         QDeclarativeCompiledBindingsPrivate::Subscription *sub = (subscriptions + subIndex);

   689         sub->target = q;

   690         sub->targetMethod = methodCount + subIndex;

   691         sub->connect(&p->idValues[idIndex].bindings);

   692     }

   693 }

   694  

   695 void QDeclarativeCompiledBindingsPrivate::subscribe(QObject *o, int notifyIndex, int subIndex)

   696 {

   697     Q_Q(QDeclarativeCompiledBindings);

   698 

   699     QDeclarativeCompiledBindingsPrivate::Subscription *sub = (subscriptions + subIndex);

   700     sub->target = q;

   701     sub->targetMethod = methodCount + subIndex; 

   702     if (o)

   703         sub->connect(o, notifyIndex);

   704     else

   705         sub->disconnect();

   706 }

   707 

   708 // Conversion functions - these MUST match the QtScript expression path

   709 inline static qreal toReal(Register *reg, int type, bool *ok = 0)

   710 {

   711     if (ok) *ok = true;

   712 

   713     if (type == QMetaType::QReal) {

   714         return reg->getqreal();

   715     } else if (type == qMetaTypeId<QVariant>()) {

   716         return reg->getvariantptr()->toReal();

   717     } else {

   718         if (ok) *ok = false;

   719         return 0;

   720     }

   721 }

   722 

   723 inline static QString toString(Register *reg, int type, bool *ok = 0)

   724 {

   725     if (ok) *ok = true;

   726 

   727     if (type == QMetaType::QReal) {

   728         return QString::number(reg->getqreal());

   729     } else if (type == QMetaType::Int) {

   730         return QString::number(reg->getint());

   731     } else if (type == qMetaTypeId<QVariant>()) {

   732         return reg->getvariantptr()->toString();

   733     } else if (type == QMetaType::QString) {

   734         return *reg->getstringptr();

   735     } else {

   736         if (ok) *ok = false;

   737         return QString();

   738     }

   739 }

   740 

   741 inline static bool toBool(Register *reg, int type, bool *ok = 0)

   742 {

   743     if (ok) *ok = true;

   744 

   745     if (type == QMetaType::Bool) {

   746         return reg->getbool();

   747     } else if (type == qMetaTypeId<QVariant>()) {

   748         return reg->getvariantptr()->toBool();

   749     } else {

   750         if (ok) *ok = false;

   751         return false;

   752     }

   753 }

   754 

   755 inline static QUrl toUrl(Register *reg, int type, QDeclarativeContextData *context, bool *ok = 0)

   756 {

   757     if (ok) *ok = true;

   758 

   759     QUrl base;

   760     if (type == qMetaTypeId<QVariant>()) {

   761         QVariant *var = reg->getvariantptr();

   762         int vt = var->type();

   763         if (vt == QVariant::Url) {

   764             base = var->toUrl();

   765         } else if (vt == QVariant::ByteArray) {

   766             base = QUrl(QString::fromUtf8(var->toByteArray()));

   767         } else if (vt == QVariant::String) {

   768             base = QUrl(var->toString());

   769         } else {

   770             if (ok) *ok = false;

   771             return QUrl();

   772         }

   773     } else if (type == QMetaType::QString) {

   774         base = QUrl(*reg->getstringptr());

   775     } else {

   776         if (ok) *ok = false;

   777         return QUrl();

   778     }

   779 

   780     if (!base.isEmpty() && base.isRelative())

   781         return context->url.resolved(base);

   782     else

   783         return base;

   784 }

   785 

   786 static QObject *variantToQObject(const QVariant &value, bool *ok)

   787 {

   788     if (ok) *ok = true;

   789 

   790     if (value.userType() == QMetaType::QObjectStar) {

   791         return qvariant_cast<QObject*>(value);

   792     } else {

   793         if (ok) *ok = false;

   794         return 0;

   795     }

   796 }

   797 

   798 bool QDeclarativeCompiledBindingsPrivate::findproperty(QObject *obj, Register *output, 

   799                                                        QDeclarativeEnginePrivate *enginePriv,

   800                                                        int subIdx, const QScriptDeclarativeClass::Identifier &name,

   801                                                        bool isTerminal)

   802 {

   803     if (!obj) {

   804         output->setUndefined();

   805         return false;

   806     }

   807 

   808     QDeclarativePropertyCache::Data local;

   809     QDeclarativePropertyCache::Data *property = 

   810         QDeclarativePropertyCache::property(QDeclarativeEnginePrivate::get(enginePriv), obj, name, local);

   811 

   812     if (property) {

   813         if (subIdx != -1)

   814             subscribe(obj, property->notifyIndex, subIdx);

   815 

   816         if (property->flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {

   817             void *args[] = { output->typeDataPtr(), 0 };

   818             QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);

   819             output->settype(QMetaType::QObjectStar);

   820         } else if (property->propType == qMetaTypeId<QVariant>()) {

   821             QVariant v;

   822             void *args[] = { &v, 0 };

   823             QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);

   824 

   825             if (isTerminal) {

   826                 new (output->typeDataPtr()) QVariant(v);

   827                 output->settype(qMetaTypeId<QVariant>());

   828             } else {

   829                 bool ok;

   830                 output->setQObject(variantToQObject(v, &ok));

   831                 if (!ok) 

   832                     output->setUndefined();

   833                 else

   834                     output->settype(QMetaType::QObjectStar);

   835             }

   836 

   837         } else {

   838             if (!isTerminal) {

   839                 output->setUndefined();

   840             } else if (property->propType == QMetaType::QReal) {

   841                 void *args[] = { output->typeDataPtr(), 0 };

   842                 QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);

   843                 output->settype(QMetaType::QReal);

   844             } else if (property->propType == QMetaType::Int) {

   845                 void *args[] = { output->typeDataPtr(), 0 };

   846                 QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);

   847                 output->settype(QMetaType::Int);

   848             } else if (property->propType == QMetaType::Bool) {

   849                 void *args[] = { output->typeDataPtr(), 0 };

   850                 QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);

   851                 output->settype(QMetaType::Bool);

   852             } else if (property->propType == QMetaType::QString) {

   853                 new (output->typeDataPtr()) QString();

   854                 void *args[] = { output->typeDataPtr(), 0 };

   855                 QMetaObject::metacall(obj, QMetaObject::ReadProperty, property->coreIndex, args);

   856                 output->settype(QMetaType::QString);

   857             } else {

   858                 new (output->typeDataPtr()) 

   859                     QVariant(obj->metaObject()->property(property->coreIndex).read(obj));

   860                 output->settype(qMetaTypeId<QVariant>());

   861             }

   862         }

   863 

   864         return true;

   865     } else {

   866         output->setUndefined();

   867         return false;

   868     }

   869 }

   870 

   871 void QDeclarativeCompiledBindingsPrivate::findgeneric(Register *output, 

   872                                                       int subIdx,      

   873                                                       QDeclarativeContextData *context,

   874                                                       const QScriptDeclarativeClass::Identifier &name, 

   875                                                       bool isTerminal)

   876 {

   877     QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(context->engine);

   878 

   879     while (context) {

   880 

   881         int contextPropertyIndex = context->propertyNames?context->propertyNames->value(name):-1;

   882 

   883 

   884         if (contextPropertyIndex != -1) {

   885 

   886             if (contextPropertyIndex < context->idValueCount) {

   887                 output->setQObject(context->idValues[contextPropertyIndex]);

   888                 output->settype(QMetaType::QObjectStar);

   889 

   890                 if (subIdx != -1) 

   891                     subscribeId(context, contextPropertyIndex, subIdx);

   892 

   893             } else {

   894                 QDeclarativeContextPrivate *cp = context->asQDeclarativeContextPrivate();

   895                 const QVariant &value = cp->propertyValues.at(contextPropertyIndex);

   896 

   897                 if (isTerminal) {

   898                     new (output->typeDataPtr()) QVariant(value);

   899                     output->settype(qMetaTypeId<QVariant>());

   900                 } else {

   901                     bool ok;

   902                     output->setQObject(variantToQObject(value, &ok));

   903                     if (!ok) { output->setUndefined(); }

   904                     else { output->settype(QMetaType::QObjectStar); }

   905                     return;

   906                 }

   907 

   908                 if (subIdx != -1) 

   909                     subscribe(context->asQDeclarativeContext(), contextPropertyIndex + cp->notifyIndex, subIdx);

   910 

   911 

   912             }

   913 

   914             return;

   915         }

   916 

   917         if (QObject *root = context->contextObject) {

   918 

   919             if (findproperty(root, output, enginePriv, subIdx, name, isTerminal))

   920                 return;

   921 

   922         }

   923 

   924         context = context->parent;

   925     }

   926 

   927     output->setUndefined();

   928 }

   929 

   930 void QDeclarativeCompiledBindingsPrivate::init()

   931 {

   932     Program *program = (Program *)programData;

   933     if (program->subscriptions)

   934         subscriptions = new QDeclarativeCompiledBindingsPrivate::Subscription[program->subscriptions];

   935     if (program->identifiers)

   936         identifiers = new QScriptDeclarativeClass::PersistentIdentifier[program->identifiers];

   937 

   938     m_signalTable = (quint32 *)(program->data() + program->signalTableOffset);

   939     m_bindings = new QDeclarativeCompiledBindingsPrivate::Binding[program->bindings];

   940 }

   941 

   942 static void throwException(int id, QDeclarativeDelayedError *error, 

   943                            Program *program, QDeclarativeContextData *context,

   944                            const QString &description = QString())

   945 {

   946     error->error.setUrl(context->url);

   947     if (description.isEmpty())

   948         error->error.setDescription(QLatin1String("TypeError: Result of expression is not an object"));

   949     else

   950         error->error.setDescription(description);

   951     if (id != 0xFF) {

   952         quint64 e = *((quint64 *)(program->data() + program->exceptionDataOffset) + id); 

   953         error->error.setLine((e >> 32) & 0xFFFFFFFF);

   954         error->error.setColumn(e & 0xFFFFFFFF); 

   955     } else {

   956         error->error.setLine(-1);

   957         error->error.setColumn(-1);

   958     }

   959     if (!context->engine || !error->addError(QDeclarativeEnginePrivate::get(context->engine)))

   960         QDeclarativeEnginePrivate::warning(context->engine, error->error);

   961 }

   962 

   963 static void dumpInstruction(const Instr *instr)

   964 {

   965     switch (instr->common.type) {

   966     case Instr::Noop:

   967         qWarning().nospace() << "\t" << "Noop";

   968         break;

   969     case Instr::BindingId:

   970         qWarning().nospace() << instr->id.line << ":" << instr->id.column << ":";

   971         break;

   972     case Instr::Subscribe:

   973         qWarning().nospace() << "\t" << "Subscribe" << "\t\t" << instr->subscribe.offset << "\t" << instr->subscribe.reg << "\t" << instr->subscribe.index;

   974         break;

   975     case Instr::SubscribeId:

   976         qWarning().nospace() << "\t" << "SubscribeId" << "\t\t" << instr->subscribe.offset << "\t" << instr->subscribe.reg << "\t" << instr->subscribe.index;

   977         break;

   978     case Instr::FetchAndSubscribe:

   979         qWarning().nospace() << "\t" << "FetchAndSubscribe" << "\t" << instr->fetchAndSubscribe.output << "\t" << instr->fetchAndSubscribe.objectReg << "\t" << instr->fetchAndSubscribe.subscription;

   980         break;

   981     case Instr::LoadId:

   982         qWarning().nospace() << "\t" << "LoadId" << "\t\t\t" << instr->load.index << "\t" << instr->load.reg;

   983         break;

   984     case Instr::LoadScope:

   985         qWarning().nospace() << "\t" << "LoadScope" << "\t\t" << instr->load.index << "\t" << instr->load.reg;

   986         break;

   987     case Instr::LoadRoot:

   988         qWarning().nospace() << "\t" << "LoadRoot" << "\t\t" << instr->load.index << "\t" << instr->load.reg;

   989         break;

   990     case Instr::LoadAttached:

   991         qWarning().nospace() << "\t" << "LoadAttached" << "\t\t" << instr->attached.output << "\t" << instr->attached.reg << "\t" << instr->attached.index;

   992         break;

   993     case Instr::ConvertIntToReal:

   994         qWarning().nospace() << "\t" << "ConvertIntToReal" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;

   995         break;

   996     case Instr::ConvertRealToInt:

   997         qWarning().nospace() << "\t" << "ConvertRealToInt" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;

   998         break;

   999     case Instr::Real:

  1000         qWarning().nospace() << "\t" << "Real" << "\t\t\t" << instr->real_value.reg << "\t" << instr->real_value.value;

  1001         break;

  1002     case Instr::Int:

  1003         qWarning().nospace() << "\t" << "Int" << "\t\t\t" << instr->int_value.reg << "\t" << instr->int_value.value;

  1004         break;

  1005     case Instr::Bool:

  1006         qWarning().nospace() << "\t" << "Bool" << "\t\t\t" << instr->bool_value.reg << "\t" << instr->bool_value.value;

  1007         break;

  1008     case Instr::String:

  1009         qWarning().nospace() << "\t" << "String" << "\t\t\t" << instr->string_value.reg << "\t" << instr->string_value.offset << "\t" << instr->string_value.length;

  1010         break;

  1011     case Instr::AddReal:

  1012         qWarning().nospace() << "\t" << "AddReal" << "\t\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1013         break;

  1014     case Instr::AddInt:

  1015         qWarning().nospace() << "\t" << "AddInt" << "\t\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1016         break;

  1017     case Instr::AddString:

  1018         qWarning().nospace() << "\t" << "AddString" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1019         break;

  1020     case Instr::MinusReal:

  1021         qWarning().nospace() << "\t" << "MinusReal" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1022         break;

  1023     case Instr::MinusInt:

  1024         qWarning().nospace() << "\t" << "MinusInt" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1025         break;

  1026     case Instr::CompareReal:

  1027         qWarning().nospace() << "\t" << "CompareReal" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1028         break;

  1029     case Instr::CompareString:

  1030         qWarning().nospace() << "\t" << "CompareString" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1031         break;

  1032     case Instr::NotCompareReal:

  1033         qWarning().nospace() << "\t" << "NotCompareReal" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1034         break;

  1035     case Instr::NotCompareString:

  1036         qWarning().nospace() << "\t" << "NotCompareString" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1037         break;

  1038     case Instr::GreaterThanReal:

  1039         qWarning().nospace() << "\t" << "GreaterThanReal" << "\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1040         break;

  1041     case Instr::MaxReal:

  1042         qWarning().nospace() << "\t" << "MaxReal" << "\t\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1043         break;

  1044     case Instr::MinReal:

  1045         qWarning().nospace() << "\t" << "MinReal" << "\t\t\t" << instr->binaryop.output << "\t" << instr->binaryop.src1 << "\t" << instr->binaryop.src2;

  1046         break;

  1047     case Instr::NewString:

  1048         qWarning().nospace() << "\t" << "NewString" << "\t\t" << instr->construct.reg;

  1049         break;

  1050     case Instr::NewUrl:

  1051         qWarning().nospace() << "\t" << "NewUrl" << "\t\t\t" << instr->construct.reg;

  1052         break;

  1053     case Instr::CleanupString:

  1054         qWarning().nospace() << "\t" << "CleanupString" << "\t\t" << instr->cleanup.reg;

  1055         break;

  1056     case Instr::CleanupUrl:

  1057         qWarning().nospace() << "\t" << "CleanupUrl" << "\t\t" << instr->cleanup.reg;

  1058         break;

  1059     case Instr::Fetch:

  1060         qWarning().nospace() << "\t" << "Fetch" << "\t\t\t" << instr->fetch.output << "\t" << instr->fetch.index << "\t" << instr->fetch.objectReg;

  1061         break;

  1062     case Instr::Store:

  1063         qWarning().nospace() << "\t" << "Store" << "\t\t\t" << instr->store.output << "\t" << instr->store.index << "\t" << instr->store.reg;

  1064         break;

  1065     case Instr::Copy:

  1066         qWarning().nospace() << "\t" << "Copy" << "\t\t\t" << instr->copy.reg << "\t" << instr->copy.src;

  1067         break;

  1068     case Instr::Skip:

  1069         qWarning().nospace() << "\t" << "Skip" << "\t\t\t" << instr->skip.reg << "\t" << instr->skip.count;

  1070         break;

  1071     case Instr::Done:

  1072         qWarning().nospace() << "\t" << "Done";

  1073         break;

  1074     case Instr::InitString:

  1075         qWarning().nospace() << "\t" << "InitString" << "\t\t" << instr->initstring.offset << "\t" << instr->initstring.dataIdx;

  1076         break;

  1077     case Instr::FindGeneric:

  1078         qWarning().nospace() << "\t" << "FindGeneric" << "\t\t" << instr->find.reg << "\t" << instr->find.name;

  1079         break;

  1080     case Instr::FindGenericTerminal:

  1081         qWarning().nospace() << "\t" << "FindGenericTerminal" << "\t" << instr->find.reg << "\t" <<  instr->find.name;

  1082         break;

  1083     case Instr::FindProperty:

  1084         qWarning().nospace() << "\t" << "FindProperty" << "\t\t" << instr->find.reg << "\t" << instr->find.src << "\t" << instr->find.name;

  1085         break;

  1086     case Instr::FindPropertyTerminal:

  1087         qWarning().nospace() << "\t" << "FindPropertyTerminal" << "\t" << instr->find.reg << "\t" << instr->find.src << "\t" << instr->find.name;

  1088         break;

  1089     case Instr::CleanupGeneric:

  1090         qWarning().nospace() << "\t" << "CleanupGeneric" << "\t\t" << instr->cleanup.reg;

  1091         break;

  1092     case Instr::ConvertGenericToReal:

  1093         qWarning().nospace() << "\t" << "ConvertGenericToReal" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;

  1094         break;

  1095     case Instr::ConvertGenericToBool:

  1096         qWarning().nospace() << "\t" << "ConvertGenericToBool" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;

  1097         break;

  1098     case Instr::ConvertGenericToString:

  1099         qWarning().nospace() << "\t" << "ConvertGenericToString" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;

  1100         break;

  1101     case Instr::ConvertGenericToUrl:

  1102         qWarning().nospace() << "\t" << "ConvertGenericToUrl" << "\t" << instr->unaryop.output << "\t" << instr->unaryop.src;

  1103         break;

  1104     default:

  1105         qWarning().nospace() << "\t" << "Unknown";

  1106         break;

  1107     }

  1108 }

  1109 

  1110 void QDeclarativeCompiledBindingsPrivate::run(int instrIndex,

  1111                                               QDeclarativeContextData *context, QDeclarativeDelayedError *error,

  1112                                               QObject *scope, QObject *output, QDeclarativePropertyPrivate::WriteFlags storeFlags)

  1113 {

  1114     Q_Q(QDeclarativeCompiledBindings);

  1115 

  1116     error->removeError();

  1117 

  1118     Register registers[32];

  1119 

  1120     QDeclarativeEnginePrivate *engine = QDeclarativeEnginePrivate::get(context->engine);

  1121     Program *program = (Program *)programData;

  1122     const Instr *instr = program->instructions();

  1123     instr += instrIndex;

  1124     const char *data = program->data();

  1125 

  1126 #ifdef QML_THREADED_INTERPRETER

  1127     static void *decode_instr[] = {

  1128         FOR_EACH_QML_INSTR(QML_INSTR_ADDR)

  1129     };

  1130 

  1131     if (!program->compiled) {

  1132         program->compiled = true;

  1133         const Instr *inop = program->instructions();