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

**

** 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$

**

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

#include "private/qdeclarativevme_p.h"

#include "private/qdeclarativecompiler_p.h"

#include "private/qdeclarativeboundsignal_p.h"

#include "private/qdeclarativestringconverters_p.h"

#include "private/qmetaobjectbuilder_p.h"

#include "private/qdeclarativedata_p.h"

#include "qdeclarative.h"

#include "private/qdeclarativecustomparser_p.h"

#include "qdeclarativeengine.h"

#include "qdeclarativecontext.h"

#include "qdeclarativecomponent.h"

#include "private/qdeclarativebinding_p.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativecomponent_p.h"

#include "private/qdeclarativevmemetaobject_p.h"

#include "private/qdeclarativebinding_p_p.h"

#include "private/qdeclarativecontext_p.h"

#include "private/qdeclarativecompiledbindings_p.h"

#include "private/qdeclarativeglobal_p.h"

#include "qdeclarativescriptstring.h"

#include <QStack>

#include <QWidget>

#include <QColor>

#include <QPointF>

#include <QSizeF>

#include <QRectF>

#include <QtCore/qdebug.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdatetime.h>

QT_BEGIN_NAMESPACE

QDeclarativeVME::QDeclarativeVME()

{

}

#define VME_EXCEPTION(desc) \

    { \

        QDeclarativeError error; \

        error.setDescription(desc.trimmed()); \

        error.setLine(instr.line); \

        error.setUrl(comp->url); \

        vmeErrors << error; \

        break; \

    }

struct ListInstance

{

    ListInstance() 

        : type(0) {}

    ListInstance(int t) 

        : type(t) {}

    int type;

    QDeclarativeListProperty<void> qListProperty;

};

QObject *QDeclarativeVME::run(QDeclarativeContextData *ctxt, QDeclarativeCompiledData *comp, 

                              int start, int count, const QBitField &bindingSkipList)

{

    QDeclarativeVMEStack<QObject *> stack;

    if (start == -1) start = 0;

    if (count == -1) count = comp->bytecode.count();

    return run(stack, ctxt, comp, start, count, bindingSkipList);

}

void QDeclarativeVME::runDeferred(QObject *object)

{

    QDeclarativeData *data = QDeclarativeData::get(object);

    if (!data || !data->context || !data->deferredComponent)

        return;

    QDeclarativeContextData *ctxt = data->context;

    QDeclarativeCompiledData *comp = data->deferredComponent;

    int start = data->deferredIdx + 1;

    int count = data->deferredComponent->bytecode.at(data->deferredIdx).defer.deferCount;

    QDeclarativeVMEStack<QObject *> stack;

    stack.push(object);

    run(stack, ctxt, comp, start, count, QBitField());

}

QObject *QDeclarativeVME::run(QDeclarativeVMEStack<QObject *> &stack, 

                              QDeclarativeContextData *ctxt, 

                              QDeclarativeCompiledData *comp, 

                              int start, int count, 

                              const QBitField &bindingSkipList)

{

    Q_ASSERT(comp);

    Q_ASSERT(ctxt);

    const QList<QDeclarativeCompiledData::TypeReference> &types = comp->types;

    const QList<QString> &primitives = comp->primitives;

    const QList<QByteArray> &datas = comp->datas;

    const QList<QDeclarativeCompiledData::CustomTypeData> &customTypeData = comp->customTypeData;

    const QList<int> &intData = comp->intData;

    const QList<float> &floatData = comp->floatData;

    const QList<QDeclarativePropertyCache *> &propertyCaches = comp->propertyCaches;

    const QList<QDeclarativeParser::Object::ScriptBlock> &scripts = comp->scripts;

    const QList<QUrl> &urls = comp->urls;

    QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding> bindValues;

    QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus> parserStatus;

    QDeclarativeVMEStack<ListInstance> qliststack;

    vmeErrors.clear();

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

    int status = -1;    //for dbus

    QDeclarativePropertyPrivate::WriteFlags flags = QDeclarativePropertyPrivate::BypassInterceptor;

    for (int ii = start; !isError() && ii < (start + count); ++ii) {

        const QDeclarativeInstruction &instr = comp->bytecode.at(ii);

        switch(instr.type) {

        case QDeclarativeInstruction::Init:

            {

                if (instr.init.bindingsSize) 

                    bindValues = QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding>(instr.init.bindingsSize);

                if (instr.init.parserStatusSize)

                    parserStatus = QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus>(instr.init.parserStatusSize);

                if (instr.init.contextCache != -1) 

                    ctxt->setIdPropertyData(comp->contextCaches.at(instr.init.contextCache));

                if (instr.init.compiledBinding != -1) 

                    ctxt->optimizedBindings = new QDeclarativeCompiledBindings(datas.at(instr.init.compiledBinding).constData(), ctxt);

            }

            break;

        case QDeclarativeInstruction::CreateObject:

            {

                QBitField bindings;

                if (instr.create.bindingBits != -1) {

                    const QByteArray &bits = datas.at(instr.create.bindingBits);

                    bindings = QBitField((const quint32*)bits.constData(),

                                         bits.size() * 8);

                }

                if (stack.isEmpty())

                    bindings = bindings.united(bindingSkipList);

                QObject *o = 

                    types.at(instr.create.type).createInstance(ctxt, bindings);

                if (!o) {

                    if(types.at(instr.create.type).component)

                        vmeErrors << types.at(instr.create.type).component->errors();

                    VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create object of type %1").arg(QString::fromLatin1(types.at(instr.create.type).className)));

                }

                QDeclarativeData *ddata = QDeclarativeData::get(o);

                Q_ASSERT(ddata);

                if (stack.isEmpty()) {

                    if (ddata->context) {

                        Q_ASSERT(ddata->context != ctxt);

                        Q_ASSERT(ddata->outerContext);

                        Q_ASSERT(ddata->outerContext != ctxt);

                        QDeclarativeContextData *c = ddata->context;

                        while (c->linkedContext) c = c->linkedContext;

                        c->linkedContext = ctxt;

                    } else {

                        ctxt->addObject(o);

                    }

                    ddata->ownContext = true;

                } else if (!ddata->context) {

                    ctxt->addObject(o);

                }

                ddata->setImplicitDestructible();

                ddata->outerContext = ctxt;

                ddata->lineNumber = instr.line;

                ddata->columnNumber = instr.create.column;

                if (instr.create.data != -1) {

                    QDeclarativeCustomParser *customParser =

                        types.at(instr.create.type).type->customParser();

                    customParser->setCustomData(o, datas.at(instr.create.data));

                }

                if (!stack.isEmpty()) {

                    QObject *parent = stack.top();

                    if (o->isWidgetType()) { 

                        QWidget *widget = static_cast<QWidget*>(o); 

                        if (parent->isWidgetType()) { 

                            QWidget *parentWidget = static_cast<QWidget*>(parent); 

                            widget->setParent(parentWidget); 

                        } else { 

                            // TODO: parent might be a layout 

                        } 

                    } else { 

			    QDeclarative_setParent_noEvent(o, parent);

                    } 

                }

                stack.push(o);

            }

            break;

        case QDeclarativeInstruction::CreateSimpleObject:

            {

                QObject *o = (QObject *)operator new(instr.createSimple.typeSize + 

                                                     sizeof(QDeclarativeData));   

                ::memset(o, 0, instr.createSimple.typeSize + sizeof(QDeclarativeData));

                instr.createSimple.create(o);

                QDeclarativeData *ddata = 

                    (QDeclarativeData *)(((const char *)o) + instr.createSimple.typeSize);

                ddata->lineNumber = instr.line;

                ddata->columnNumber = instr.createSimple.column;

                QObjectPrivate::get(o)->declarativeData = ddata;                                                      

                ddata->context = ddata->outerContext = ctxt;

                ddata->nextContextObject = ctxt->contextObjects; 

                if (ddata->nextContextObject) 

                    ddata->nextContextObject->prevContextObject = &ddata->nextContextObject; 

                ddata->prevContextObject = &ctxt->contextObjects; 

                ctxt->contextObjects = ddata; 

                QObject *parent = stack.top();                                                                    

                QDeclarative_setParent_noEvent(o, parent);                                                        

                stack.push(o);

            }

            break;

        case QDeclarativeInstruction::SetId:

            {

                QObject *target = stack.top();

                ctxt->setIdProperty(instr.setId.index, target);

            }

            break;

        case QDeclarativeInstruction::SetDefault:

            {

                ctxt->contextObject = stack.top();

            }

            break;

        case QDeclarativeInstruction::CreateComponent:

            {

                QDeclarativeComponent *qcomp = 

                    new QDeclarativeComponent(ctxt->engine, comp, ii + 1, instr.createComponent.count,

                                              stack.isEmpty() ? 0 : stack.top());

                QDeclarativeData *ddata = QDeclarativeData::get(qcomp, true);

                Q_ASSERT(ddata);

                ctxt->addObject(qcomp);

                if (stack.isEmpty()) 

                    ddata->ownContext = true;

                ddata->setImplicitDestructible();

                ddata->outerContext = ctxt;

                ddata->lineNumber = instr.line;

                ddata->columnNumber = instr.create.column;

                QDeclarativeComponentPrivate::get(qcomp)->creationContext = ctxt;

                stack.push(qcomp);

                ii += instr.createComponent.count;

            }

            break;

        case QDeclarativeInstruction::StoreMetaObject:

            {

                QObject *target = stack.top();

                QMetaObject mo;

                const QByteArray &metadata = datas.at(instr.storeMeta.data);

                QMetaObjectBuilder::fromRelocatableData(&mo, 0, metadata);

                const QDeclarativeVMEMetaData *data = 

                    (const QDeclarativeVMEMetaData *)datas.at(instr.storeMeta.aliasData).constData();

                (void)new QDeclarativeVMEMetaObject(target, &mo, data, comp);

                QDeclarativeData *ddata = QDeclarativeData::get(target, true);

                if (ddata->propertyCache) ddata->propertyCache->release();

                ddata->propertyCache = propertyCaches.at(instr.storeMeta.propertyCache);

                ddata->propertyCache->addref();

            }

            break;

        case QDeclarativeInstruction::StoreVariant:

            {

                QObject *target = stack.top();

                // XXX - can be more efficient

                QVariant v = QDeclarativeStringConverters::variantFromString(primitives.at(instr.storeString.value));

                void *a[] = { &v, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeString.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreVariantInteger:

            {

                QObject *target = stack.top();

                QVariant v(instr.storeInteger.value);

                void *a[] = { &v, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeString.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreVariantDouble:

            {

                QObject *target = stack.top();

                QVariant v(instr.storeDouble.value);

                void *a[] = { &v, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeString.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreVariantBool:

            {

                QObject *target = stack.top();

                QVariant v(instr.storeBool.value);

                void *a[] = { &v, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeString.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreString:

            {

                QObject *target = stack.top();

                void *a[] = { (void *)&primitives.at(instr.storeString.value), 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeString.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreUrl:

            {

                QObject *target = stack.top();

                void *a[] = { (void *)&urls.at(instr.storeUrl.value), 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeUrl.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreFloat:

            {

                QObject *target = stack.top();

                float f = instr.storeFloat.value;

                void *a[] = { &f, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty,

                                      instr.storeFloat.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreDouble:

            {

                QObject *target = stack.top();

                double d = instr.storeDouble.value;

                void *a[] = { &d, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty,

                                      instr.storeDouble.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreBool:

            {

                QObject *target = stack.top();

                void *a[] = { (void *)&instr.storeBool.value, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeBool.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreInteger:

            {

                QObject *target = stack.top();

                void *a[] = { (void *)&instr.storeInteger.value, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeInteger.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreColor:

            {

                QObject *target = stack.top();

                QColor c = QColor::fromRgba(instr.storeColor.value);

                void *a[] = { &c, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeColor.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreDate:

            {

                QObject *target = stack.top();

                QDate d = QDate::fromJulianDay(instr.storeDate.value);

                void *a[] = { &d, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeDate.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreTime:

            {

                QObject *target = stack.top();

                QTime t;

                t.setHMS(intData.at(instr.storeTime.valueIndex),

                         intData.at(instr.storeTime.valueIndex+1),

                         intData.at(instr.storeTime.valueIndex+2),

                         intData.at(instr.storeTime.valueIndex+3));

                void *a[] = { &t, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeTime.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreDateTime:

            {

                QObject *target = stack.top();

                QTime t;

                t.setHMS(intData.at(instr.storeDateTime.valueIndex+1),

                         intData.at(instr.storeDateTime.valueIndex+2),

                         intData.at(instr.storeDateTime.valueIndex+3),

                         intData.at(instr.storeDateTime.valueIndex+4));

                QDateTime dt(QDate::fromJulianDay(intData.at(instr.storeDateTime.valueIndex)), t);

                void *a[] = { &dt, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty,

                                      instr.storeDateTime.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StorePoint:

            {

                QObject *target = stack.top();

                QPoint p = QPointF(floatData.at(instr.storeRealPair.valueIndex),

                                   floatData.at(instr.storeRealPair.valueIndex+1)).toPoint();

                void *a[] = { &p, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeRealPair.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StorePointF:

            {

                QObject *target = stack.top();

                QPointF p(floatData.at(instr.storeRealPair.valueIndex),

                          floatData.at(instr.storeRealPair.valueIndex+1));

                void *a[] = { &p, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeRealPair.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreSize:

            {

                QObject *target = stack.top();

                QSize p = QSizeF(floatData.at(instr.storeRealPair.valueIndex),

                                 floatData.at(instr.storeRealPair.valueIndex+1)).toSize();

                void *a[] = { &p, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeRealPair.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreSizeF:

            {

                QObject *target = stack.top();

                QSizeF s(floatData.at(instr.storeRealPair.valueIndex),

                         floatData.at(instr.storeRealPair.valueIndex+1));

                void *a[] = { &s, 0, &status, &flags };

                QMetaObject::metacall(target, QMetaObject::WriteProperty, 

                                      instr.storeRealPair.propertyIndex, a);

            }

            break;

        case QDeclarativeInstruction::StoreRect:

            {

                QObject *target = stack.top();

                QRect r = QRectF(floatData.at(instr.storeRect.valueIndex),

                                 floatData.at(instr.storeRect.valueIndex+1),

                                 floatData.at(instr.storeRect.valueIndex+2),

                                 floatData.at(instr.storeRect.valueIndex+3)).toRect();