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 #include "private/qdeclarativecompiler_p.h"

    43 

    44 #include "private/qdeclarativecompositetypedata_p.h"

    45 #include "private/qdeclarativeparser_p.h"

    46 #include "private/qdeclarativescriptparser_p.h"

    47 #include "qdeclarativepropertyvaluesource.h"

    48 #include "qdeclarativecomponent.h"

    49 #include "private/qmetaobjectbuilder_p.h"

    50 #include "private/qdeclarativestringconverters_p.h"

    51 #include "private/qdeclarativeengine_p.h"

    52 #include "qdeclarativeengine.h"

    53 #include "qdeclarativecontext.h"

    54 #include "private/qdeclarativemetatype_p.h"

    55 #include "private/qdeclarativecustomparser_p_p.h"

    56 #include "private/qdeclarativecontext_p.h"

    57 #include "private/qdeclarativecomponent_p.h"

    58 #include "parser/qdeclarativejsast_p.h"

    59 #include "private/qdeclarativevmemetaobject_p.h"

    60 #include "private/qdeclarativeexpression_p.h"

    61 #include "private/qdeclarativeproperty_p.h"

    62 #include "private/qdeclarativerewrite_p.h"

    63 #include "qdeclarativescriptstring.h"

    64 #include "private/qdeclarativeglobal_p.h"

    65 #include "private/qdeclarativescriptparser_p.h"

    66 #include "private/qdeclarativebinding_p.h"

    67 #include "private/qdeclarativecompiledbindings_p.h"

    68 #include "private/qdeclarativeglobalscriptclass_p.h"

    69 

    70 #include <QColor>

    71 #include <QDebug>

    72 #include <QPointF>

    73 #include <QSizeF>

    74 #include <QRectF>

    75 #include <QAtomicInt>

    76 #include <QtCore/qdebug.h>

    77 #include <QtCore/qdatetime.h>

    78 

    79 QT_BEGIN_NAMESPACE

    80 

    81 DEFINE_BOOL_CONFIG_OPTION(compilerDump, QML_COMPILER_DUMP);

    82 DEFINE_BOOL_CONFIG_OPTION(compilerStatDump, QML_COMPILER_STATS);

    83 DEFINE_BOOL_CONFIG_OPTION(bindingsDump, QML_BINDINGS_DUMP);

    84 

    85 using namespace QDeclarativeParser;

    86 

    87 /*!

    88     Instantiate a new QDeclarativeCompiler.

    89 */

    90 QDeclarativeCompiler::QDeclarativeCompiler()

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

    92 {

    93 }

    94 

    95 /*!

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

    97 

    98     \sa errors()

    99 */

   100 bool QDeclarativeCompiler::isError() const

   101 {

   102     return !exceptions.isEmpty();

   103 }

   104 

   105 /*!

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

   107     if there were no errors.

   108 */

   109 QList<QDeclarativeError> QDeclarativeCompiler::errors() const

   110 {

   111     return exceptions;

   112 }

   113 

   114 /*!

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

   116 

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

   118 */

   119 bool QDeclarativeCompiler::isAttachedPropertyName(const QByteArray &name)

   120 {

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

   122 }

   123 

   124 /*!

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

   126 

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

   128     letter.

   129 */

   130 bool QDeclarativeCompiler::isSignalPropertyName(const QByteArray &name)

   131 {

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

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

   134 }

   135 

   136 /*!

   137     \macro COMPILE_EXCEPTION

   138     \internal

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

   140     (failure).

   141 

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

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

   144 

   145     For example:

   146 

   147     \code

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

   149     \endcode

   150 */

   151 #define COMPILE_EXCEPTION(token, desc) \

   152     {  \

   153         QString exceptionDescription; \

   154         QDeclarativeError error; \

   155         error.setUrl(output->url); \

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

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

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

   159         exceptions << error; \

   160         return false; \

   161     }

   162 

   163 /*!

   164     \macro COMPILE_CHECK

   165     \internal

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

   167 */

   168 #define COMPILE_CHECK(a) \

   169     { \

   170         if (!a) return false; \

   171     }

   172 

   173 /*!

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

   175     false.

   176 

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

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

   179 */

   180 bool QDeclarativeCompiler::testLiteralAssignment(const QMetaProperty &prop,

   181                                         QDeclarativeParser::Value *v)

   182 {

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

   184 

   185     if (!prop.isWritable())

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

   187 

   188     if (prop.isEnumType()) {

   189         int value;

   190         if (prop.isFlagType()) {

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

   192         } else

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

   194         if (value == -1)

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

   196         return true;

   197     }

   198     int type = prop.userType();

   199     switch(type) {

   200         case -1:

   201             break;

   202         case QVariant::String:

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

   204             break;

   205         case QVariant::Url:

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

   207             break;

   208         case QVariant::UInt:

   209             {

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

   211             if (ok) {

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

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

   214                     ok = false;

   215             }

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

   217             }

   218             break;

   219         case QVariant::Int:

   220             {

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

   222             if (ok) {

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

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

   225                     ok = false;

   226             }

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

   228             }

   229             break;

   230         case QMetaType::Float:

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

   232             break;

   233         case QVariant::Double:

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

   235             break;

   236         case QVariant::Color:

   237             {

   238             bool ok;

   239             QDeclarativeStringConverters::colorFromString(string, &ok);

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

   241             }

   242             break;

   243         case QVariant::Date:

   244             {

   245             bool ok;

   246             QDeclarativeStringConverters::dateFromString(string, &ok);

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

   248             }

   249             break;

   250         case QVariant::Time:

   251             {

   252             bool ok;

   253             QDeclarativeStringConverters::timeFromString(string, &ok);

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

   255             }

   256             break;

   257         case QVariant::DateTime:

   258             {

   259             bool ok;

   260             QDeclarativeStringConverters::dateTimeFromString(string, &ok);

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

   262             }

   263             break;

   264         case QVariant::Point:

   265         case QVariant::PointF:

   266             {

   267             bool ok;

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

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

   270             }

   271             break;

   272         case QVariant::Size:

   273         case QVariant::SizeF:

   274             {

   275             bool ok;

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

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

   278             }

   279             break;

   280         case QVariant::Rect:

   281         case QVariant::RectF:

   282             {

   283             bool ok;

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

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

   286             }

   287             break;

   288         case QVariant::Bool:

   289             {

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

   291             }

   292             break;

   293         case QVariant::Vector3D:

   294             {

   295             bool ok;

   296             QDeclarativeStringConverters::vector3DFromString(string, &ok);

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

   298             }

   299             break;

   300         default:

   301             {

   302             int t = prop.userType();

   303             QDeclarativeMetaType::StringConverter converter =

   304                 QDeclarativeMetaType::customStringConverter(t);

   305             if (!converter)

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

   307             }

   308             break;

   309     }

   310     return true;

   311 }

   312 

   313 /*!

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

   315 

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

   317     a corresponding action in this method.

   318 */

   319 void QDeclarativeCompiler::genLiteralAssignment(const QMetaProperty &prop,

   320                                        QDeclarativeParser::Value *v)

   321 {

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

   323 

   324     QDeclarativeInstruction instr;

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

   326     if (prop.isEnumType()) {

   327         int value;

   328         if (prop.isFlagType()) {

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

   330         } else

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

   332 

   333         instr.type = QDeclarativeInstruction::StoreInteger;

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

   335         instr.storeInteger.value = value;

   336         output->bytecode << instr;

   337         return;

   338     }

   339 

   340     int type = prop.userType();

   341     switch(type) {

   342         case -1:

   343             {

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

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

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

   347                     instr.type = QDeclarativeInstruction::StoreVariantInteger;

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

   349                     instr.storeInteger.value = int(n);

   350                 } else {

   351                     instr.type = QDeclarativeInstruction::StoreVariantDouble;

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

   353                     instr.storeDouble.value = n;

   354                 }

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

   356                 instr.type = QDeclarativeInstruction::StoreVariantBool;

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

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

   359             } else {

   360                 instr.type = QDeclarativeInstruction::StoreVariant;

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

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

   363             }

   364             }

   365             break;

   366         case QVariant::String:

   367             {

   368             instr.type = QDeclarativeInstruction::StoreString;

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

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

   371             }

   372             break;

   373         case QVariant::Url:

   374             {

   375             instr.type = QDeclarativeInstruction::StoreUrl;

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

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

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

   379             }

   380             break;

   381         case QVariant::UInt:

   382             {

   383             instr.type = QDeclarativeInstruction::StoreInteger;

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

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

   386             }

   387             break;

   388         case QVariant::Int:

   389             {

   390             instr.type = QDeclarativeInstruction::StoreInteger;

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

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

   393             }

   394             break;

   395         case QMetaType::Float:

   396             {

   397             instr.type = QDeclarativeInstruction::StoreFloat;

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

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

   400             }

   401             break;

   402         case QVariant::Double:

   403             {

   404             instr.type = QDeclarativeInstruction::StoreDouble;

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

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

   407             }

   408             break;

   409         case QVariant::Color:

   410             {

   411             QColor c = QDeclarativeStringConverters::colorFromString(string);

   412             instr.type = QDeclarativeInstruction::StoreColor;

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

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

   415             }

   416             break;

   417         case QVariant::Date:

   418             {

   419             QDate d = QDeclarativeStringConverters::dateFromString(string);

   420             instr.type = QDeclarativeInstruction::StoreDate;

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

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

   423             }

   424             break;

   425         case QVariant::Time:

   426             {

   427             QTime time = QDeclarativeStringConverters::timeFromString(string);

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

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

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

   431             instr.type = QDeclarativeInstruction::StoreTime;

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

   433             instr.storeTime.valueIndex = index;

   434             }

   435             break;

   436         case QVariant::DateTime:

   437             {

   438             QDateTime dateTime = QDeclarativeStringConverters::dateTimeFromString(string);

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

   440                            dateTime.time().hour(),

   441                            dateTime.time().minute(),

   442                            dateTime.time().second(),

   443                            dateTime.time().msec() };

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

   445             instr.type = QDeclarativeInstruction::StoreDateTime;

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

   447             instr.storeDateTime.valueIndex = index;

   448             }

   449             break;

   450         case QVariant::Point:

   451         case QVariant::PointF:

   452             {

   453             bool ok;

   454             QPointF point =

   455                 QDeclarativeStringConverters::pointFFromString(string, &ok);

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

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

   458             if (type == QVariant::PointF)

   459                 instr.type = QDeclarativeInstruction::StorePointF;

   460             else

   461                 instr.type = QDeclarativeInstruction::StorePoint;

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

   463             instr.storeRealPair.valueIndex = index;

   464             }

   465             break;

   466         case QVariant::Size:

   467         case QVariant::SizeF:

   468             {

   469             bool ok;

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

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

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

   473             if (type == QVariant::SizeF)

   474                 instr.type = QDeclarativeInstruction::StoreSizeF;

   475             else

   476                 instr.type = QDeclarativeInstruction::StoreSize;

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

   478             instr.storeRealPair.valueIndex = index;

   479             }

   480             break;

   481         case QVariant::Rect:

   482         case QVariant::RectF:

   483             {

   484             bool ok;

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

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

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

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

   489             if (type == QVariant::RectF)

   490                 instr.type = QDeclarativeInstruction::StoreRectF;

   491             else

   492                 instr.type = QDeclarativeInstruction::StoreRect;

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

   494             instr.storeRect.valueIndex = index;

   495             }

   496             break;

   497         case QVariant::Bool:

   498             {

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

   500             instr.type = QDeclarativeInstruction::StoreBool;

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

   502             instr.storeBool.value = b;

   503             }

   504             break;

   505         case QVariant::Vector3D:

   506             {

   507             bool ok;

   508             QVector3D vector =

   509                 QDeclarativeStringConverters::vector3DFromString(string, &ok);

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

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

   512             instr.type = QDeclarativeInstruction::StoreVector3D;

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

   514             instr.storeRealPair.valueIndex = index;

   515             }

   516             break;

   517         default:

   518             {

   519             int t = prop.userType();

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

   521             instr.type = QDeclarativeInstruction::AssignCustomType;

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

   523             instr.assignCustomType.valueIndex = index;

   524 

   525             QDeclarativeCompiledData::CustomTypeData data;

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

   527             data.type = t;

   528             output->customTypeData << data;

   529             }

   530             break;

   531     }

   532     output->bytecode << instr;

   533 }

   534 

   535 /*!

   536     Resets data by clearing the lists that the QDeclarativeCompiler modifies.

   537 */

   538 void QDeclarativeCompiler::reset(QDeclarativeCompiledData *data)

   539 {

   540     data->types.clear();

   541     data->primitives.clear();

   542     data->floatData.clear();

   543     data->intData.clear();

   544     data->customTypeData.clear();

   545     data->datas.clear();

   546     data->bytecode.clear();

   547 }

   548 

   549 /*!

   550     Compile \a unit, and store the output in \a out.  \a engine is the QDeclarativeEngine

   551     with which the QDeclarativeCompiledData will be associated.

   552 

   553     Returns true on success, false on failure.  On failure, the compile errors

   554     are available from errors().

   555 

   556     If the environment variant QML_COMPILER_DUMP is set

   557     (eg. QML_COMPILER_DUMP=1) the compiled instructions will be dumped to stderr

   558     on a successful compiler.

   559 */

   560 bool QDeclarativeCompiler::compile(QDeclarativeEngine *engine,

   561                                    QDeclarativeCompositeTypeData *unit,

   562                                    QDeclarativeCompiledData *out)

   563 {

   564     exceptions.clear();

   565 

   566     Q_ASSERT(out);

   567     reset(out);

   568 

   569     output = out;

   570 

   571     // Compile types

   572     for (int ii = 0; ii < unit->types.count(); ++ii) {

   573         QDeclarativeCompositeTypeData::TypeReference &tref = unit->types[ii];

   574         QDeclarativeCompiledData::TypeReference ref;

   575         QDeclarativeScriptParser::TypeReference *parserRef = unit->data.referencedTypes().at(ii);

   576         if (tref.type) {

   577             ref.type = tref.type;

   578             if (!ref.type->isCreatable()) {

   579                 QString err = ref.type->noCreationReason();

   580                 if (err.isEmpty())

   581                     err = tr( "Element is not creatable.");

   582                 COMPILE_EXCEPTION(parserRef->refObjects.first(), err);

   583             }

   584         } else if (tref.unit) {

   585             ref.component = tref.unit->toComponent(engine);

   586 

   587             if (ref.component->isError()) {

   588                 QDeclarativeError error;

   589                 error.setUrl(output->url);

   590                 error.setDescription(QLatin1String("Unable to create type ") +

   591                                      parserRef->name);

   592                 if (!parserRef->refObjects.isEmpty()) {

   593                     QDeclarativeParser::Object *parserObject = parserRef->refObjects.first();

   594                     error.setLine(parserObject->location.start.line);

   595                     error.setColumn(parserObject->location.start.column);

   596                 }

   597 

   598                 exceptions << error;

   599                 exceptions << ref.component->errors();

   600                 reset(out);

   601                 return false;

   602             }

   603             ref.ref = tref.unit;

   604             ref.ref->addref();

   605         }

   606         ref.className = parserRef->name.toUtf8();

   607         out->types << ref;

   608     }

   609 

   610     Object *root = unit->data.tree();

   611     Q_ASSERT(root);

   612 

   613     this->engine = engine;

   614     this->enginePrivate = QDeclarativeEnginePrivate::get(engine);

   615     this->unit = unit;

   616     this->unitRoot = root;

   617     compileTree(root);

   618 

   619     if (!isError()) {

   620         if (compilerDump())

   621             out->dumpInstructions();

   622         if (compilerStatDump())

   623             dumpStats();

   624     } else {

   625         reset(out);

   626     }

   627 

   628     compileState = ComponentCompileState();

   629     savedCompileStates.clear();

   630     output = 0;

   631     this->engine = 0;

   632     this->enginePrivate = 0;

   633     this->unit = 0;

   634     this->unitRoot = 0;

   635 

   636     return !isError();

   637 }

   638 

   639 void QDeclarativeCompiler::compileTree(Object *tree)

   640 {

   641     compileState.root = tree;

   642     componentStat.lineNumber = tree->location.start.line;

   643 

   644     if (!buildObject(tree, BindingContext()) || !completeComponentBuild())

   645         return;

   646 

   647     QDeclarativeInstruction init;

   648     init.type = QDeclarativeInstruction::Init;

   649     init.line = 0;

   650     init.init.bindingsSize = compileState.bindings.count();

   651     init.init.parserStatusSize = compileState.parserStatusCount;

   652     init.init.contextCache = genContextCache();

   653     if (compileState.compiledBindingData.isEmpty())

   654         init.init.compiledBinding = -1;

   655     else

   656         init.init.compiledBinding = output->indexForByteArray(compileState.compiledBindingData);

   657     output->bytecode << init;

   658 

   659     // Build global import scripts

   660     QHash<QString, Object::ScriptBlock> importedScripts;

   661     QStringList importedScriptIndexes;

   662 

   663     for (int ii = 0; ii < unit->scripts.count(); ++ii) {

   664         QString scriptCode = QString::fromUtf8(unit->scripts.at(ii).resource->data);

   665         Object::ScriptBlock::Pragmas pragmas = QDeclarativeScriptParser::extractPragmas(scriptCode);

   666 

   667         if (!scriptCode.isEmpty()) {

   668             Object::ScriptBlock &scriptBlock = importedScripts[unit->scripts.at(ii).qualifier];

   669 

   670             scriptBlock.codes.append(scriptCode);

   671             scriptBlock.lineNumbers.append(1);

   672             scriptBlock.files.append(unit->scripts.at(ii).resource->url);

   673             scriptBlock.pragmas.append(pragmas);

   674         }

   675     }

   676 

   677     for (QHash<QString, Object::ScriptBlock>::Iterator iter = importedScripts.begin(); 

   678          iter != importedScripts.end(); ++iter) {

   679 

   680         importedScriptIndexes.append(iter.key());

   681 

   682         QDeclarativeInstruction import;

   683         import.type = QDeclarativeInstruction::StoreImportedScript;

   684         import.line = 0;

   685         import.storeScript.value = output->scripts.count();

   686         output->scripts << *iter;

   687         output->bytecode << import;

   688     }

   689 

   690     genObject(tree);

   691 

   692     QDeclarativeInstruction def;

   693     init.line = 0;

   694     def.type = QDeclarativeInstruction::SetDefault;

   695     output->bytecode << def;

   696 

   697     output->importCache = new QDeclarativeTypeNameCache(engine);

   698 

   699     for (int ii = 0; ii < importedScriptIndexes.count(); ++ii) 

   700         output->importCache->add(importedScriptIndexes.at(ii), ii);

   701 

   702     unit->imports.cache(output->importCache, engine);

   703 

   704     Q_ASSERT(tree->metatype);

   705 

   706     if (tree->metadata.isEmpty()) {

   707         output->root = tree->metatype;

   708     } else {

   709         static_cast<QMetaObject &>(output->rootData) = *tree->metaObject();

   710         output->root = &output->rootData;

   711     }

   712     if (!tree->metadata.isEmpty()) 

   713         enginePrivate->registerCompositeType(output);

   714 }

   715 

   716 static bool ValuePtrLessThan(const Value *t1, const Value *t2) 

   717 {

   718     return t1->location.start.line < t2->location.start.line ||

   719            (t1->location.start.line == t2->location.start.line &&

   720             t1->location.start.column < t2->location.start.column);

   721 }

   722 

   723 bool QDeclarativeCompiler::buildObject(Object *obj, const BindingContext &ctxt)

   724 {

   725     componentStat.objects++;

   726 

   727     Q_ASSERT (obj->type != -1);

   728     const QDeclarativeCompiledData::TypeReference &tr =

   729         output->types.at(obj->type);

   730     obj->metatype = tr.metaObject();

   731 

   732     if (tr.component)

   733         obj->url = tr.component->url();

   734     if (tr.type)

   735         obj->typeName = tr.type->qmlTypeName();

   736     obj->className = tr.className;

   737 

   738     // This object is a "Component" element

   739     if (tr.type && obj->metatype == &QDeclarativeComponent::staticMetaObject) {

   740         COMPILE_CHECK(buildComponent(obj, ctxt));

   741         return true;

   742     } 

   743 

   744     // Object instantiations reset the binding context

   745     BindingContext objCtxt(obj);

   746 

   747     // Create the synthesized meta object, ignoring aliases

   748     COMPILE_CHECK(checkDynamicMeta(obj)); 

   749     COMPILE_CHECK(mergeDynamicMetaProperties(obj));

   750     COMPILE_CHECK(buildDynamicMeta(obj, IgnoreAliases));

   751 

   752     // Find the native type and check for the QDeclarativeParserStatus interface

   753     QDeclarativeType *type = toQmlType(obj);

   754     Q_ASSERT(type);

   755     obj->parserStatusCast = type->parserStatusCast();

   756     if (obj->parserStatusCast != -1)

   757         compileState.parserStatusCount++;

   758 

   759     // Check if this is a custom parser type.  Custom parser types allow

   760     // assignments to non-existent properties.  These assignments are then

   761     // compiled by the type.

   762     bool isCustomParser = output->types.at(obj->type).type &&

   763                           output->types.at(obj->type).type->customParser() != 0;

   764     QList<QDeclarativeCustomParserProperty> customProps;

   765 

   766     // Fetch the list of deferred properties

   767     QStringList deferredList = deferredProperties(obj);

   768 

   769     // Must do id property first.  This is to ensure that the id given to any

   770     // id reference created matches the order in which the objects are

   771     // instantiated

   772     foreach(Property *prop, obj->properties) {

   773         if (prop->name == "id") {

   774             COMPILE_CHECK(buildProperty(prop, obj, objCtxt));

   775             break;

   776         }

   777     }

   778 

   779     // Merge 

   780     Property *defaultProperty = 0;

   781     Property *skipProperty = 0;

   782     if (obj->defaultProperty) {

   783         const QMetaObject *metaObject = obj->metaObject();

   784         Q_ASSERT(metaObject);

   785         QMetaProperty p = QDeclarativeMetaType::defaultProperty(metaObject);

   786         if (p.name()) {

   787             Property *explicitProperty = obj->getProperty(p.name(), false);

   788             if (explicitProperty && !explicitProperty->value) {

   789                 skipProperty = explicitProperty;

   790 

   791                 defaultProperty = new Property;

   792                 defaultProperty->parent = obj;

   793                 defaultProperty->isDefault = true;

   794                 defaultProperty->location = obj->defaultProperty->location;

   795                 defaultProperty->listValueRange = obj->defaultProperty->listValueRange;

   796                 defaultProperty->listCommaPositions = obj->defaultProperty->listCommaPositions;

   797 

   798                 defaultProperty->values  = obj->defaultProperty->values;

   799                 defaultProperty->values += explicitProperty->values;

   800                 foreach(Value *value, defaultProperty->values)

   801                     value->addref();

   802                 qSort(defaultProperty->values.begin(), defaultProperty->values.end(), ValuePtrLessThan);

   803 

   804             } else {

   805                 defaultProperty = obj->defaultProperty;

   806                 defaultProperty->addref();

   807             }

   808         } else {

   809             defaultProperty = obj->defaultProperty;

   810             defaultProperty->addref();

   811         }

   812     }

   813 

   814     // Build all explicit properties specified

   815     foreach(Property *prop, obj->properties) {

   816 

   817         if (prop == skipProperty)

   818             continue;

   819         if (prop->name == "id")

   820             continue;

   821 

   822         bool canDefer = false;

   823         if (isCustomParser) {

   824             if (doesPropertyExist(prop, obj)) {

   825                 int ids = compileState.ids.count();

   826                 COMPILE_CHECK(buildProperty(prop, obj, objCtxt));

   827                 canDefer = ids == compileState.ids.count();

   828             } else {

   829                 customProps << QDeclarativeCustomParserNodePrivate::fromProperty(prop);

   830             }

   831         } else {

   832             if (isSignalPropertyName(prop->name)) {

   833                 COMPILE_CHECK(buildSignal(prop,obj,objCtxt));

   834             } else {

   835                 int ids = compileState.ids.count();

   836                 COMPILE_CHECK(buildProperty(prop, obj, objCtxt));

   837                 canDefer = ids == compileState.ids.count();

   838             }

   839         }

   840 

   841         if (canDefer && !deferredList.isEmpty() &&

   842             deferredList.contains(QString::fromUtf8(prop->name)))

   843             prop->isDeferred = true;

   844 

   845     }

   846 

   847     // Build the default property

   848     if (defaultProperty)  {

   849         Property *prop = defaultProperty;

   850 

   851         bool canDefer = false;

   852         if (isCustomParser) {

   853             if (doesPropertyExist(prop, obj)) {

   854                 int ids = compileState.ids.count();

   855                 COMPILE_CHECK(buildProperty(prop, obj, objCtxt));

   856                 canDefer = ids == compileState.ids.count();

   857             } else {

   858                 customProps << QDeclarativeCustomParserNodePrivate::fromProperty(prop);

   859             }

   860         } else {

   861             int ids = compileState.ids.count();

   862             COMPILE_CHECK(buildProperty(prop, obj, objCtxt));

   863             canDefer = ids == compileState.ids.count();

   864         }

   865 

   866         if (canDefer && !deferredList.isEmpty() &&

   867             deferredList.contains(QString::fromUtf8(prop->name)))

   868             prop->isDeferred = true;

   869     }

   870 

   871     if (defaultProperty) 

   872         defaultProperty->release();

   873 

   874     // Compile custom parser parts

   875     if (isCustomParser/* && !customProps.isEmpty()*/) {

   876         QDeclarativeCustomParser *cp = output->types.at(obj->type).type->customParser();

   877         cp->clearErrors();

   878         cp->compiler = this;

   879         cp->object = obj;

   880         obj->custom = cp->compile(customProps);

   881         cp->compiler = 0;

   882         cp->object = 0;

   883         foreach (QDeclarativeError err, cp->errors()) {

   884             err.setUrl(output->url);

   885             exceptions << err;

   886         }

   887     }

   888 

   889     return true;

   890 }

   891 

   892 void QDeclarativeCompiler::genObject(QDeclarativeParser::Object *obj)

   893 {

   894     const QDeclarativeCompiledData::TypeReference &tr =

   895         output->types.at(obj->type);

   896     if (tr.type && obj->metatype == &QDeclarativeComponent::staticMetaObject) {

   897         genComponent(obj);

   898         return;

   899     }

   900 

   901     // Create the object

   902     if (obj->custom.isEmpty() && output->types.at(obj->type).type &&

   903         !output->types.at(obj->type).type->isExtendedType() && obj != compileState.root) {

   904 

   905         QDeclarativeInstruction create;

   906         create.type = QDeclarativeInstruction::CreateSimpleObject;

   907         create.line = obj->location.start.line;

   908         create.createSimple.create = output->types.at(obj->type).type->createFunction();

   909         create.createSimple.typeSize = output->types.at(obj->type).type->createSize();

   910         create.createSimple.column = obj->location.start.column;

   911         output->bytecode << create;

   912 

   913     } else {

   914 

   915         QDeclarativeInstruction create;

   916         create.type = QDeclarativeInstruction::CreateObject;

   917         create.line = obj->location.start.line;

   918         create.create.column = obj->location.start.column;

   919         create.create.data = -1;

   920         if (!obj->custom.isEmpty())

   921             create.create.data = output->indexForByteArray(obj->custom);

   922         create.create.type = obj->type;

   923         if (!output->types.at(create.create.type).type && 

   924             !obj->bindingBitmask.isEmpty()) {

   925             Q_ASSERT(obj->bindingBitmask.size() % 4 == 0);

   926             create.create.bindingBits = 

   927                 output->indexForByteArray(obj->bindingBitmask);

   928         } else {

   929             create.create.bindingBits = -1;

   930         }

   931         output->bytecode << create;

   932 

   933     }

   934 

   935     // Setup the synthesized meta object if necessary

   936     if (!obj->metadata.isEmpty()) {

   937         QDeclarativeInstruction meta;

   938         meta.type = QDeclarativeInstruction::StoreMetaObject;

   939         meta.line = 0;

   940         meta.storeMeta.data = output->indexForByteArray(obj->metadata);

   941         meta.storeMeta.aliasData = output->indexForByteArray(obj->synthdata);

   942         meta.storeMeta.propertyCache = output->propertyCaches.count();

   943         // ### Surely the creation of this property cache could be more efficient

   944         QDeclarativePropertyCache *propertyCache = 0;

   945         if (tr.component)

   946             propertyCache = QDeclarativeComponentPrivate::get(tr.component)->cc->rootPropertyCache->copy();

   947         else

   948             propertyCache = enginePrivate->cache(obj->metaObject()->superClass())->copy();

   949 

   950         propertyCache->append(engine, obj->metaObject(), QDeclarativePropertyCache::Data::NoFlags,

   951                               QDeclarativePropertyCache::Data::IsVMEFunction);

   952 

   953         if (obj == unitRoot) {

   954             propertyCache->addref();

   955             output->rootPropertyCache = propertyCache;

   956         }

   957 

   958         output->propertyCaches << propertyCache;

   959         output->bytecode << meta;

   960     } else if (obj == unitRoot) {

   961         if (tr.component)

   962             output->rootPropertyCache = QDeclarativeComponentPrivate::get(tr.component)->cc->rootPropertyCache;

   963         else

   964             output->rootPropertyCache = enginePrivate->cache(obj->metaObject());

   965 

   966         output->rootPropertyCache->addref();

   967     }

   968 

   969     // Set the object id

   970     if (!obj->id.isEmpty()) {

   971         QDeclarativeInstruction id;

   972         id.type = QDeclarativeInstruction::SetId;

   973         id.line = 0;

   974         id.setId.value = output->indexForString(obj->id);

   975         id.setId.index = obj->idIndex;

   976         output->bytecode << id;

   977     }

   978 

   979     // Begin the class

   980     if (obj->parserStatusCast != -1) {

   981         QDeclarativeInstruction begin;

   982         begin.type = QDeclarativeInstruction::BeginObject;

   983         begin.begin.castValue = obj->parserStatusCast;

   984         begin.line = obj->location.start.line;

   985         output->bytecode << begin;

   986     }

   987 

   988     genObjectBody(obj);

   989 }

   990 

   991 void QDeclarativeCompiler::genObjectBody(QDeclarativeParser::Object *obj)

   992 {

   993     typedef QPair<Property *, int> PropPair;

   994     foreach(const PropPair &prop, obj->scriptStringProperties) {

   995         QDeclarativeInstruction ss;

   996         ss.type = QDeclarativeInstruction::StoreScriptString;

   997         ss.storeScriptString.propertyIndex = prop.first->index;

   998         ss.storeScriptString.value = 

   999             output->indexForString(prop.first->values.at(0)->value.asScript());

  1000         ss.storeScriptString.scope = prop.second;

  1001         output->bytecode << ss;

  1002     }

  1003 

  1004     bool seenDefer = false;

  1005     foreach(Property *prop, obj->valueProperties) {

  1006         if (prop->isDeferred) {

  1007             seenDefer = true;

  1008             continue;

  1009         }

  1010         genValueProperty(prop, obj);

  1011     }

  1012     if (seenDefer) {

  1013         QDeclarativeInstruction defer;

  1014         defer.type = QDeclarativeInstruction::Defer;

  1015         defer.line = 0;

  1016         defer.defer.deferCount = 0;

  1017         int deferIdx = output->bytecode.count();

  1018         output->bytecode << defer;

  1019 

  1020         QDeclarativeInstruction init;

  1021         init.type = QDeclarativeInstruction::Init;

  1022         init.init.bindingsSize = compileState.bindings.count(); // XXX - bigger than necessary

  1023         init.init.parserStatusSize = compileState.parserStatusCount; // XXX - bigger than necessary

  1024         init.init.contextCache = -1;

  1025         init.init.compiledBinding = -1;

  1026         output->bytecode << init;

  1027 

  1028         foreach(Property *prop, obj->valueProperties) {

  1029             if (!prop->isDeferred)

  1030                 continue;

  1031             genValueProperty(prop, obj);

  1032         }

  1033 

  1034         output->bytecode[deferIdx].defer.deferCount =

  1035             output->bytecode.count() - deferIdx - 1;

  1036     }

  1037 

  1038     foreach(Property *prop, obj->signalProperties) {

  1039 

  1040         QDeclarativeParser::Value *v = prop->values.at(0);

  1041 

  1042         if (v->type == Value::SignalObject) {

  1043 

  1044             genObject(v->object);

  1045 

  1046             QDeclarativeInstruction assign;

  1047             assign.type = QDeclarativeInstruction::AssignSignalObject;

  1048             assign.line = v->location.start.line;

  1049             assign.assignSignalObject.signal =

  1050                 output->indexForByteArray(prop->name);

  1051             output->bytecode << assign;

  1052 

  1053         } else if (v->type == Value::SignalExpression) {

  1054 

  1055             BindingContext ctxt = compileState.signalExpressions.value(v);

  1056 

  1057             QDeclarativeInstruction store;

  1058             store.type = QDeclarativeInstruction::StoreSignal;

  1059             store.line = v->location.start.line;

  1060             store.storeSignal.signalIndex = prop->index;

  1061             store.storeSignal.value =

  1062                 output->indexForString(v->value.asScript().trimmed());

  1063             store.storeSignal.context = ctxt.stack;

  1064             output->bytecode << store;

  1065 

  1066         }

  1067 

  1068     }

  1069 

  1070     foreach(Property *prop, obj->attachedProperties) {

  1071         QDeclarativeInstruction fetch;

  1072         fetch.type = QDeclarativeInstruction::FetchAttached;

  1073         fetch.line = prop->location.start.line;

  1074         fetch.fetchAttached.id = prop->index;

  1075         output->bytecode << fetch;

  1076 

  1077         genObjectBody(prop->value);

  1078 

  1079         QDeclarativeInstruction pop;

  1080         pop.type = QDeclarativeInstruction::PopFetchedObject;

  1081         pop.line = prop->location.start.line;

  1082         output->bytecode << pop;

  1083     }

  1084 

  1085     foreach(Property *prop, obj->groupedProperties) {

  1086         QDeclarativeInstruction fetch;

  1087         fetch.type = QDeclarativeInstruction::FetchObject;

  1088         fetch.fetch.property = prop->index;

  1089         fetch.line = prop->location.start.line;

  1090         output->bytecode << fetch;

  1091 

  1092         if (!prop->value->metadata.isEmpty()) {

  1093             QDeclarativeInstruction meta;

  1094             meta.type = QDeclarativeInstruction::StoreMetaObject;

  1095             meta.line = 0;

  1096             meta.storeMeta.data = output->indexForByteArray(prop->value->metadata);

  1097             meta.storeMeta.aliasData = output->indexForByteArray(prop->value->synthdata);

  1098             meta.storeMeta.propertyCache = output->propertyCaches.count();

  1099             // ### Surely the creation of this property cache could be more efficient

  1100             QDeclarativePropertyCache *propertyCache =

  1101                 enginePrivate->cache(prop->value->metaObject()->superClass())->copy();

  1102             propertyCache->append(engine, prop->value->metaObject(), QDeclarativePropertyCache::Data::NoFlags,

  1103                                   QDeclarativePropertyCache::Data::IsVMEFunction);

  1104 

  1105             output->propertyCaches << propertyCache;

  1106             output->bytecode << meta;

  1107         }

  1108 

  1109         genObjectBody(prop->value);

  1110 

  1111         QDeclarativeInstruction pop;

  1112         pop.type = QDeclarativeInstruction::PopFetchedObject;

  1113         pop.line = prop->location.start.line;

  1114         output->bytecode << pop;

  1115     }

  1116 

  1117     foreach(Property *prop, obj->valueTypeProperties) {

  1118         QDeclarativeInstruction fetch;

  1119         fetch.type = QDeclarativeInstruction::FetchValueType;

  1120         fetch.fetchValue.property = prop->index;

  1121         fetch.fetchValue.type = prop->type;

  1122         fetch.line = prop->location.start.line;

  1123 

  1124         output->bytecode << fetch;

  1125 

  1126         foreach(Property *vprop, prop->value->valueProperties) {

  1127             genPropertyAssignment(vprop, prop->value, prop);

  1128         }

  1129 

  1130         QDeclarativeInstruction pop;

  1131         pop.type = QDeclarativeInstruction::PopValueType;

  1132         pop.fetchValue.property = prop->index;

  1133         pop.fetchValue.type = prop->type;

  1134         pop.line = prop->location.start.line;