/****************************************************************************

**

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

**

****************************************************************************/

// #define COMPILEDBINDINGS_DEBUG

#include "private/qdeclarativecompiledbindings_p.h"

#include <QtDeclarative/qdeclarativeinfo.h>

#include <private/qdeclarativecontext_p.h>

#include <private/qdeclarativejsast_p.h>

#include <private/qdeclarativejsengine_p.h>

#include <private/qdeclarativeexpression_p.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdebug.h>

#include <QtCore/qnumeric.h>

#include <private/qdeclarativeanchors_p_p.h>

#include <private/qdeclarativeglobal_p.h>

#include <private/qdeclarativefastproperties_p.h>

QT_BEGIN_NAMESPACE

DEFINE_BOOL_CONFIG_OPTION(qmlExperimental, QML_EXPERIMENTAL);

DEFINE_BOOL_CONFIG_OPTION(qmlDisableOptimizer, QML_DISABLE_OPTIMIZER);

DEFINE_BOOL_CONFIG_OPTION(qmlDisableFastProperties, QML_DISABLE_FAST_PROPERTIES);

DEFINE_BOOL_CONFIG_OPTION(bindingsDump, QML_BINDINGS_DUMP);

Q_GLOBAL_STATIC(QDeclarativeFastProperties, fastProperties);

#  define QML_THREADED_INTERPRETER

#endif

#define FOR_EACH_QML_INSTR(F) \

    F(Noop)                    /* Nop */ \

    F(BindingId)               /* id */ \

    F(Subscribe)               /* subscribe */ \

    F(SubscribeId)             /* subscribe */ \

    F(FetchAndSubscribe)       /* fetchAndSubscribe */ \

    F(LoadId)                  /* load */ \

    F(LoadScope)               /* load */ \

    F(LoadRoot)                /* load */ \

    F(LoadAttached)            /* attached */ \

    F(ConvertIntToReal)        /* unaryop */ \

    F(ConvertRealToInt)        /* unaryop */ \

    F(Real)                    /* real_value */ \

    F(Int)                     /* int_value */ \

    F(Bool)                    /* bool_value */ \

    F(String)                  /* string_value */ \

    F(AddReal)                 /* binaryop */ \

    F(AddInt)                  /* binaryop */ \

    F(AddString)               /* binaryop */ \

    F(MinusReal)               /* binaryop */ \

    F(MinusInt)                /* binaryop */ \

    F(CompareReal)             /* binaryop */ \

    F(CompareString)           /* binaryop */ \

    F(NotCompareReal)          /* binaryop */ \

    F(NotCompareString)        /* binaryop */ \

    F(GreaterThanReal)         /* binaryop */ \

    F(MaxReal)                 /* binaryop */ \

    F(MinReal)                 /* binaryop */ \

    F(NewString)               /* construct */ \

    F(NewUrl)                  /* construct */ \

    F(CleanupUrl)              /* cleanup */ \

    F(CleanupString)           /* cleanup */ \

    F(Copy)                    /* copy */ \

    F(Fetch)                   /* fetch */ \

    F(Store)                   /* store */ \

    F(Skip)                    /* skip */ \

    F(Done)                    /* done */ \

    /* Speculative property resolution */ \

    F(InitString)              /* initstring */ \

    F(FindGeneric)             /* find */ \

    F(FindGenericTerminal)     /* find */ \

    F(FindProperty)            /* find */ \

    F(FindPropertyTerminal)    /* find */ \

    F(CleanupGeneric)          /* cleanup */ \

    F(ConvertGenericToReal)    /* unaryop */ \

    F(ConvertGenericToBool)    /* unaryop */ \

    F(ConvertGenericToString)  /* unaryop */ \

    F(ConvertGenericToUrl)     /* unaryop */

#define QML_INSTR_ENUM(I) I,

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

#ifdef QML_THREADED_INTERPRETER

#  define QML_BEGIN_INSTR(I) op_##I:

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

#  define QML_INSTR_HEADER void *code;

#else

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

#  define QML_END_INSTR(I) break;

#  define QML_INSTR_HEADER

#endif

using namespace QDeclarativeJS;

namespace {

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

struct Register {

    void setUndefined() { type = 0; }

    void setUnknownButDefined() { type = -1; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    int gettype() const { return type; }

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

    int type;          // Optional type

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

};

}

class QDeclarativeCompiledBindingsPrivate : public QObjectPrivate

{

    Q_DECLARE_PUBLIC(QDeclarativeCompiledBindings)

public:

    QDeclarativeCompiledBindingsPrivate();

    virtual ~QDeclarativeCompiledBindingsPrivate();

    struct Binding : public QDeclarativeAbstractBinding, public QDeclarativeDelayedError {

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

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

        // Inherited from QDeclarativeAbstractBinding

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

        virtual int propertyIndex();

        virtual void update(QDeclarativePropertyPrivate::WriteFlags flags);

        virtual void destroy();

        int index:30;

        bool enabled:1;

        bool updating:1;

        int property;

        QObject *scope;

        QObject *target;

        QDeclarativeCompiledBindingsPrivate *parent;

    };

    typedef QDeclarativeNotifierEndpoint Subscription;

    Subscription *subscriptions;

    QScriptDeclarativeClass::PersistentIdentifier *identifiers;

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

    const char *programData;

    Binding *m_bindings;

    quint32 *m_signalTable;

    static int methodCount;

    void init();

    void run(int instr, QDeclarativeContextData *context, 

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

    inline void unsubscribe(int subIndex);

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

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

    QDeclarativePropertyCache::Data *findproperty(QObject *obj, 

                                                  const QScriptDeclarativeClass::Identifier &name,

                                                  QDeclarativeEnginePrivate *enginePriv, 

                                                  QDeclarativePropertyCache::Data &local);

    bool findproperty(QObject *obj, 

                      Register *output, 

                      QDeclarativeEnginePrivate *enginePriv,

                      int subIdx, 

                      const QScriptDeclarativeClass::Identifier &name,

                      bool isTerminal);

    void findgeneric(Register *output,                                 // value output

                     int subIdx,                                       // Subscription index in config

                     QDeclarativeContextData *context,                 // Context to search in

                     const QScriptDeclarativeClass::Identifier &name, 

                     bool isTerminal);

};

QDeclarativeCompiledBindingsPrivate::QDeclarativeCompiledBindingsPrivate()

: subscriptions(0), identifiers(0)

{

}

QDeclarativeCompiledBindingsPrivate::~QDeclarativeCompiledBindingsPrivate()

{

    delete [] subscriptions; subscriptions = 0;

    delete [] identifiers; identifiers = 0;

}

int QDeclarativeCompiledBindingsPrivate::methodCount = -1;

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

: QObject(*(new QDeclarativeCompiledBindingsPrivate))

{

    Q_D(QDeclarativeCompiledBindings);

    if (d->methodCount == -1)

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

    d->programData = program;

    d->init();

    QDeclarativeAbstractExpression::setContext(context);

}

QDeclarativeCompiledBindings::~QDeclarativeCompiledBindings()

{

    Q_D(QDeclarativeCompiledBindings);

    delete [] d->m_bindings;

}

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

                                                        QObject *scope, int property)

{

    Q_D(QDeclarativeCompiledBindings);

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

    rv->index = index;

    rv->property = property;

    rv->target = target;

    rv->scope = scope;

    rv->parent = d;

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

    return rv;

}

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

{

    if (e) {

        addToObject(target);

    } else {

        removeFromObject();

    }

    QDeclarativeAbstractBinding::setEnabled(e, flags);

    if (enabled != e) {

        enabled = e;

        if (e) update(flags);

    }

}

int QDeclarativeCompiledBindingsPrivate::Binding::propertyIndex()

{

    return property & 0xFFFF;

}

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

{

    parent->run(this, flags);

}

void QDeclarativeCompiledBindingsPrivate::Binding::destroy()

{

    enabled = false;

    removeFromObject();

    clear();

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

}

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

{

    Q_D(QDeclarativeCompiledBindings);

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

        id -= d->methodCount;

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

        quint32 count = *reeval;

        ++reeval;

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

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

        }

    }

    return -1;

}

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

{

    Q_Q(QDeclarativeCompiledBindings);

    if (!binding->enabled)

        return;

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

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

        return;

    if (binding->updating) {

        QString name;

        if (binding->property & 0xFFFF0000) {

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

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

            Q_ASSERT(vt);

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

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

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

        } else {

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

        }

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

        return;

    }

    binding->updating = true;

    if (binding->property & 0xFFFF0000) {

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

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

        Q_ASSERT(vt);

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

        QObject *target = vt;

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

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

    } else {

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

    }

    binding->updating = false;

}

namespace {

// This structure is exactly 8-bytes in size

struct Instr {

    enum {

        FOR_EACH_QML_INSTR(QML_INSTR_ENUM)

    };

    union {

        struct {

            QML_INSTR_HEADER

            quint8 type;

            quint8 packing[7];

        } common;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            quint8 packing;

            quint16 column;

            quint32 line;

        } id;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            quint8 packing[3];

            quint16 subscriptions;

            quint16 identifiers;

        } init;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint16 offset;

            quint32 index;

        } subscribe;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint8 packing[2];

            quint32 index;

        } load;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 output;

            qint8 reg;

            quint8 exceptionId;

            quint32 index;

        } attached;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 output;

            qint8 reg;

            quint8 exceptionId;

            quint32 index;

        } store;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 output;

            qint8 objectReg;

            quint8 exceptionId;

            quint16 subscription;

            quint16 function;

        } fetchAndSubscribe;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 output;

            qint8 objectReg;

            quint8 exceptionId;

            quint32 index;

        } fetch;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            qint8 src;

            quint8 packing[5];

        } copy;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint8 packing[6];

        } construct;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint8 packing[2];

            float value;

        } real_value;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint8 packing[2];

            int value;

        } int_value;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            bool value;

            quint8 packing[5];

        } bool_value;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint16 length;

            quint32 offset;

        } string_value;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 output;

            qint8 src1;

            qint8 src2;

            quint8 packing[4];

        } binaryop;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 output;

            qint8 src;

            quint8 packing[5];

        } unaryop;

        struct {

            QML_INSTR_HEADER

            quint8 type;

            qint8 reg;

            quint8 packing[2];