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

**

** 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/qdeclarativecompiler_p.h"

#include "private/qdeclarativecompositetypedata_p.h"

#include "private/qdeclarativeparser_p.h"

#include "private/qdeclarativescriptparser_p.h"

#include "qdeclarativepropertyvaluesource.h"

#include "qdeclarativecomponent.h"

#include "private/qmetaobjectbuilder_p.h"

#include "private/qdeclarativestringconverters_p.h"

#include "private/qdeclarativeengine_p.h"

#include "qdeclarativeengine.h"

#include "qdeclarativecontext.h"

#include "private/qdeclarativemetatype_p.h"

#include "private/qdeclarativecustomparser_p_p.h"

#include "private/qdeclarativecontext_p.h"

#include "private/qdeclarativecomponent_p.h"

#include "parser/qdeclarativejsast_p.h"

#include "private/qdeclarativevmemetaobject_p.h"

#include "private/qdeclarativeexpression_p.h"

#include "private/qdeclarativeproperty_p.h"

#include "private/qdeclarativerewrite_p.h"

#include "qdeclarativescriptstring.h"

#include "private/qdeclarativeglobal_p.h"

#include "private/qdeclarativescriptparser_p.h"

#include "private/qdeclarativebinding_p.h"

#include "private/qdeclarativecompiledbindings_p.h"

#include "private/qdeclarativeglobalscriptclass_p.h"

#include <QColor>

#include <QDebug>

#include <QPointF>

#include <QSizeF>

#include <QRectF>

#include <QAtomicInt>

#include <QtCore/qdebug.h>

#include <QtCore/qdatetime.h>

QT_BEGIN_NAMESPACE

DEFINE_BOOL_CONFIG_OPTION(compilerDump, QML_COMPILER_DUMP);

DEFINE_BOOL_CONFIG_OPTION(compilerStatDump, QML_COMPILER_STATS);

DEFINE_BOOL_CONFIG_OPTION(bindingsDump, QML_BINDINGS_DUMP);

using namespace QDeclarativeParser;

/*!

    Instantiate a new QDeclarativeCompiler.

*/

QDeclarativeCompiler::QDeclarativeCompiler()

: output(0), engine(0), unitRoot(0), unit(0)

{

}

/*!

    Returns true if the last call to compile() caused errors.

    \sa errors()

*/

bool QDeclarativeCompiler::isError() const

{

    return !exceptions.isEmpty();

}

/*!

    Return the list of errors from the last call to compile(), or an empty list

    if there were no errors.

*/

QList<QDeclarativeError> QDeclarativeCompiler::errors() const

{

    return exceptions;

}

/*!

    Returns true if \a name refers to an attached property, false otherwise.

    Attached property names are those that start with a capital letter.

*/

bool QDeclarativeCompiler::isAttachedPropertyName(const QByteArray &name)

{

    return !name.isEmpty() && name.at(0) >= 'A' && name.at(0) <= 'Z';

}

/*!

    Returns true if \a name refers to a signal property, false otherwise.

    Signal property names are those that start with "on", followed by a capital

    letter.

*/

bool QDeclarativeCompiler::isSignalPropertyName(const QByteArray &name)

{

    return name.length() >= 3 && name.startsWith("on") &&

           'A' <= name.at(2) && 'Z' >= name.at(2);

}

/*!

    \macro COMPILE_EXCEPTION

    \internal

    Inserts an error into the QDeclarativeCompiler error list, and returns false

    (failure).

    \a token is used to source the error line and column, and \a desc is the

    error itself.  \a desc can be an expression that can be piped into QDebug.

    For example:

    \code

    COMPILE_EXCEPTION(property, tr("Error for property \"%1\"").arg(QString::fromUtf8(property->name)));

    \endcode

*/

#define COMPILE_EXCEPTION(token, desc) \

    {  \

        QString exceptionDescription; \

        QDeclarativeError error; \

        error.setUrl(output->url); \

        error.setLine((token)->location.start.line); \

        error.setColumn((token)->location.start.column); \

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

        exceptions << error; \

        return false; \

    }

/*!

    \macro COMPILE_CHECK

    \internal

    Returns false if \a is false, otherwise does nothing.

*/

#define COMPILE_CHECK(a) \

    { \

        if (!a) return false; \

    }

/*!

    Returns true if literal \a v can be assigned to property \a prop, otherwise

    false.

    This test corresponds to action taken by genLiteralAssignment().  Any change

    made here, must have a corresponding action in genLiteralAssigment().

*/

bool QDeclarativeCompiler::testLiteralAssignment(const QMetaProperty &prop,

                                        QDeclarativeParser::Value *v)

{

    QString string = v->value.asString();

    if (!prop.isWritable())

        COMPILE_EXCEPTION(v, tr("Invalid property assignment: \"%1\" is a read-only property").arg(QString::fromUtf8(prop.name())));

    if (prop.isEnumType()) {

        int value;

        if (prop.isFlagType()) {

            value = prop.enumerator().keysToValue(string.toUtf8().constData());

        } else

            value = prop.enumerator().keyToValue(string.toUtf8().constData());

        if (value == -1)

            COMPILE_EXCEPTION(v, tr("Invalid property assignment: unknown enumeration"));

        return true;

    }

    int type = prop.userType();

    switch(type) {

        case -1:

            break;

        case QVariant::String:

            if (!v->value.isString()) COMPILE_EXCEPTION(v, tr("Invalid property assignment: string expected"));

            break;

        case QVariant::Url:

            if (!v->value.isString()) COMPILE_EXCEPTION(v, tr("Invalid property assignment: url expected"));

            break;

        case QVariant::UInt:

            {

            bool ok = v->value.isNumber();

            if (ok) {

                double n = v->value.asNumber();

                if (double(uint(n)) != n)

                    ok = false;

            }

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: unsigned int expected"));

            }

            break;

        case QVariant::Int:

            {

            bool ok = v->value.isNumber();

            if (ok) {

                double n = v->value.asNumber();

                if (double(int(n)) != n)

                    ok = false;

            }

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: int expected"));

            }

            break;

        case QMetaType::Float:

            if (!v->value.isNumber()) COMPILE_EXCEPTION(v, tr("Invalid property assignment: float expected"));

            break;

        case QVariant::Double:

            if (!v->value.isNumber()) COMPILE_EXCEPTION(v, tr("Invalid property assignment: double expected"));

            break;

        case QVariant::Color:

            {

            bool ok;

            QDeclarativeStringConverters::colorFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: color expected"));

            }

            break;

        case QVariant::Date:

            {

            bool ok;

            QDeclarativeStringConverters::dateFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: date expected"));

            }

            break;

        case QVariant::Time:

            {

            bool ok;

            QDeclarativeStringConverters::timeFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: time expected"));

            }

            break;

        case QVariant::DateTime:

            {

            bool ok;

            QDeclarativeStringConverters::dateTimeFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: datetime expected"));

            }

            break;

        case QVariant::Point:

        case QVariant::PointF:

            {

            bool ok;

            QPointF point = QDeclarativeStringConverters::pointFFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: point expected"));

            }

            break;

        case QVariant::Size:

        case QVariant::SizeF:

            {

            bool ok;

            QSizeF size = QDeclarativeStringConverters::sizeFFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: size expected"));

            }

            break;

        case QVariant::Rect:

        case QVariant::RectF:

            {

            bool ok;

            QRectF rect = QDeclarativeStringConverters::rectFFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: rect expected"));

            }

            break;

        case QVariant::Bool:

            {

            if (!v->value.isBoolean()) COMPILE_EXCEPTION(v, tr("Invalid property assignment: boolean expected"));

            }

            break;

        case QVariant::Vector3D:

            {

            bool ok;

            QDeclarativeStringConverters::vector3DFromString(string, &ok);

            if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: 3D vector expected"));

            }

            break;

        default:

            {

            int t = prop.userType();

            QDeclarativeMetaType::StringConverter converter =

                QDeclarativeMetaType::customStringConverter(t);

            if (!converter)

                COMPILE_EXCEPTION(v, tr("Invalid property assignment: unsupported type \"%1\"").arg(QString::fromLatin1(QVariant::typeToName(prop.type()))));

            }

            break;

    }

    return true;

}

/*!

    Generate a store instruction for assigning literal \a v to property \a prop.

    Any literal assignment that is approved in testLiteralAssignment() must have

    a corresponding action in this method.

*/

void QDeclarativeCompiler::genLiteralAssignment(const QMetaProperty &prop,

                                       QDeclarativeParser::Value *v)

{

    QString string = v->value.asString();

    QDeclarativeInstruction instr;

    instr.line = v->location.start.line;

    if (prop.isEnumType()) {

        int value;

        if (prop.isFlagType()) {

            value = prop.enumerator().keysToValue(string.toUtf8().constData());

        } else

            value = prop.enumerator().keyToValue(string.toUtf8().constData());

        instr.type = QDeclarativeInstruction::StoreInteger;

        instr.storeInteger.propertyIndex = prop.propertyIndex();

        instr.storeInteger.value = value;

        output->bytecode << instr;

        return;

    }

    int type = prop.userType();

    switch(type) {

        case -1:

            {

            if (v->value.isNumber()) {

                double n = v->value.asNumber();

                if (double(int(n)) == n) {

                    instr.type = QDeclarativeInstruction::StoreVariantInteger;

                    instr.storeInteger.propertyIndex = prop.propertyIndex();

                    instr.storeInteger.value = int(n);

                } else {

                    instr.type = QDeclarativeInstruction::StoreVariantDouble;

                    instr.storeDouble.propertyIndex = prop.propertyIndex();

                    instr.storeDouble.value = n;

                }

            } else if(v->value.isBoolean()) {

                instr.type = QDeclarativeInstruction::StoreVariantBool;

                instr.storeBool.propertyIndex = prop.propertyIndex();

                instr.storeBool.value = v->value.asBoolean();

            } else {

                instr.type = QDeclarativeInstruction::StoreVariant;

                instr.storeString.propertyIndex = prop.propertyIndex();

                instr.storeString.value = output->indexForString(string);

            }

            }

            break;

        case QVariant::String:

            {

            instr.type = QDeclarativeInstruction::StoreString;

            instr.storeString.propertyIndex = prop.propertyIndex();

            instr.storeString.value = output->indexForString(string);

            }

            break;

        case QVariant::Url:

            {

            instr.type = QDeclarativeInstruction::StoreUrl;

            QUrl u = string.isEmpty() ? QUrl() : output->url.resolved(QUrl(string));

            instr.storeUrl.propertyIndex = prop.propertyIndex();

            instr.storeUrl.value = output->indexForUrl(u);

            }

            break;

        case QVariant::UInt:

            {

            instr.type = QDeclarativeInstruction::StoreInteger;

            instr.storeInteger.propertyIndex = prop.propertyIndex();

            instr.storeInteger.value = uint(v->value.asNumber());

            }

            break;

        case QVariant::Int:

            {

            instr.type = QDeclarativeInstruction::StoreInteger;

            instr.storeInteger.propertyIndex = prop.propertyIndex();

            instr.storeInteger.value = int(v->value.asNumber());

            }

            break;

        case QMetaType::Float:

            {

            instr.type = QDeclarativeInstruction::StoreFloat;

            instr.storeFloat.propertyIndex = prop.propertyIndex();

            instr.storeFloat.value = float(v->value.asNumber());

            }

            break;

        case QVariant::Double:

            {

            instr.type = QDeclarativeInstruction::StoreDouble;

            instr.storeDouble.propertyIndex = prop.propertyIndex();

            instr.storeDouble.value = v->value.asNumber();

            }

            break;

        case QVariant::Color:

            {

            QColor c = QDeclarativeStringConverters::colorFromString(string);

            instr.type = QDeclarativeInstruction::StoreColor;

            instr.storeColor.propertyIndex = prop.propertyIndex();

            instr.storeColor.value = c.rgba();

            }

            break;

        case QVariant::Date:

            {

            QDate d = QDeclarativeStringConverters::dateFromString(string);

            instr.type = QDeclarativeInstruction::StoreDate;

            instr.storeDate.propertyIndex = prop.propertyIndex();

            instr.storeDate.value = d.toJulianDay();

            }

            break;

        case QVariant::Time:

            {

            QTime time = QDeclarativeStringConverters::timeFromString(string);

            int data[] = { time.hour(), time.minute(),

                           time.second(), time.msec() };

            int index = output->indexForInt(data, 4);

            instr.type = QDeclarativeInstruction::StoreTime;

            instr.storeTime.propertyIndex = prop.propertyIndex();

            instr.storeTime.valueIndex = index;

            }

            break;

        case QVariant::DateTime:

            {

            QDateTime dateTime = QDeclarativeStringConverters::dateTimeFromString(string);

            int data[] = { dateTime.date().toJulianDay(),

                           dateTime.time().hour(),

                           dateTime.time().minute(),

                           dateTime.time().second(),

                           dateTime.time().msec() };

            int index = output->indexForInt(data, 5);

            instr.type = QDeclarativeInstruction::StoreDateTime;

            instr.storeDateTime.propertyIndex = prop.propertyIndex();

            instr.storeDateTime.valueIndex = index;

            }

            break;

        case QVariant::Point:

        case QVariant::PointF:

            {

            bool ok;

            QPointF point =

                QDeclarativeStringConverters::pointFFromString(string, &ok);

            float data[] = { float(point.x()), float(point.y()) };

            int index = output->indexForFloat(data, 2);

            if (type == QVariant::PointF)

                instr.type = QDeclarativeInstruction::StorePointF;

            else

                instr.type = QDeclarativeInstruction::StorePoint;

            instr.storeRealPair.propertyIndex = prop.propertyIndex();

            instr.storeRealPair.valueIndex = index;

            }

            break;

        case QVariant::Size:

        case QVariant::SizeF:

            {

            bool ok;

            QSizeF size = QDeclarativeStringConverters::sizeFFromString(string, &ok);

            float data[] = { float(size.width()), float(size.height()) };

            int index = output->indexForFloat(data, 2);

            if (type == QVariant::SizeF)

                instr.type = QDeclarativeInstruction::StoreSizeF;

            else

                instr.type = QDeclarativeInstruction::StoreSize;

            instr.storeRealPair.propertyIndex = prop.propertyIndex();

            instr.storeRealPair.valueIndex = index;

            }

            break;

        case QVariant::Rect:

        case QVariant::RectF:

            {

            bool ok;

            QRectF rect = QDeclarativeStringConverters::rectFFromString(string, &ok);

            float data[] = { float(rect.x()), float(rect.y()),

                             float(rect.width()), float(rect.height()) };

            int index = output->indexForFloat(data, 4);

            if (type == QVariant::RectF)

                instr.type = QDeclarativeInstruction::StoreRectF;

            else

                instr.type = QDeclarativeInstruction::StoreRect;

            instr.storeRect.propertyIndex = prop.propertyIndex();

            instr.storeRect.valueIndex = index;

            }

            break;

        case QVariant::Bool:

            {

            bool b = v->value.asBoolean();

            instr.type = QDeclarativeInstruction::StoreBool;

            instr.storeBool.propertyIndex = prop.propertyIndex();

            instr.storeBool.value = b;

            }

            break;

        case QVariant::Vector3D:

            {

            bool ok;

            QVector3D vector =

                QDeclarativeStringConverters::vector3DFromString(string, &ok);

            float data[] = { float(vector.x()), float(vector.y()), float(vector.z()) };

            int index = output->indexForFloat(data, 3);

            instr.type = QDeclarativeInstruction::StoreVector3D;

            instr.storeRealPair.propertyIndex = prop.propertyIndex();

            instr.storeRealPair.valueIndex = index;

            }

            break;

        default:

            {

            int t = prop.userType();

            int index = output->customTypeData.count();

            instr.type = QDeclarativeInstruction::AssignCustomType;

            instr.assignCustomType.propertyIndex = prop.propertyIndex();

            instr.assignCustomType.valueIndex = index;

            QDeclarativeCompiledData::CustomTypeData data;

            data.index = output->indexForString(string);

            data.type = t;

            output->customTypeData << data;