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

    10 -- GNU Lesser General Public License Usage

    11 -- This file may be used under the terms of the GNU Lesser

    12 -- General Public License version 2.1 as published by the Free Software

    13 -- Foundation and appearing in the file LICENSE.LGPL included in the

    14 -- packaging of this file.  Please review the following information to

    15 -- ensure the GNU Lesser General Public License version 2.1 requirements

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

    17 --

    18 -- If you have questions regarding the use of this file, please contact

    19 -- Nokia at qt-info@nokia.com.

    20 -- $QT_END_LICENSE$

    21 --

    22 ----------------------------------------------------------------------------

    23 

    24 %parser         QDeclarativeJSGrammar

    25 %decl           qdeclarativejsparser_p.h

    26 %impl           qdeclarativejsparser.cpp

    27 %expect         2

    28 %expect-rr      2

    29 

    30 %token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="

    31 %token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"

    32 %token T_COLON ":"              T_COMMA ";"                 T_CONTINUE "continue"

    33 %token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"

    34 %token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."

    35 %token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="

    36 %token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"

    37 %token T_FUNCTION "function"    T_GE ">="                   T_GT ">"

    38 %token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"

    39 %token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"

    40 %token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"

    41 %token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("

    42 %token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="

    43 %token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"

    44 %token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="

    45 %token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"

    46 %token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"

    47 %token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"

    48 %token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"

    49 %token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"

    50 %token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"

    51 %token T_STAR_EQ "*="           T_STRING_LITERAL "string literal"

    52 %token T_PROPERTY "property"    T_SIGNAL "signal"           T_READONLY "readonly"

    53 %token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"

    54 %token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"

    55 %token T_VAR "var"              T_VOID "void"               T_WHILE "while"

    56 %token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="

    57 %token T_NULL "null"            T_TRUE "true"               T_FALSE "false"

    58 %token T_CONST "const"

    59 %token T_DEBUGGER "debugger"

    60 %token T_RESERVED_WORD "reserved word"

    61 %token T_MULTILINE_STRING_LITERAL "multiline string literal"

    62 %token T_COMMENT "comment"

    63 

    64 --- context keywords.

    65 %token T_PUBLIC "public"

    66 %token T_IMPORT "import"

    67 %token T_AS "as"

    68 %token T_ON "on"

    69 

    70 --- feed tokens

    71 %token T_FEED_UI_PROGRAM

    72 %token T_FEED_UI_OBJECT_MEMBER

    73 %token T_FEED_JS_STATEMENT

    74 %token T_FEED_JS_EXPRESSION

    75 %token T_FEED_JS_SOURCE_ELEMENT

    76 %token T_FEED_JS_PROGRAM

    77 

    78 %nonassoc SHIFT_THERE

    79 %nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY

    80 %nonassoc REDUCE_HERE

    81 

    82 %start TopLevel

    83 

    84 /./****************************************************************************

    85 **

    86 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

    87 ** All rights reserved.

    88 ** Contact: Nokia Corporation (qt-info@nokia.com)

    89 **

    90 ** This file is part of the QtDeclarative module of the Qt Toolkit.

    91 **

    92 ** $QT_BEGIN_LICENSE:LGPL$

    93 ** No Commercial Usage

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

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

    96 ** contained in the Technology Preview License Agreement accompanying

    97 ** this package.

    98 **

    99 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

   106 **

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

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

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

   110 **

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

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

   113 **

   114 **

   115 **

   116 **

   117 **

   118 **

   119 **

   120 **

   121 ** $QT_END_LICENSE$

   122 **

   123 ****************************************************************************/

   124 

   125 #include <QtCore/QtDebug>

   126 #include <QtGui/QApplication>

   127 

   128 #include <string.h>

   129 

   130 #include "private/qdeclarativejsengine_p.h"

   131 #include "private/qdeclarativejslexer_p.h"

   132 #include "private/qdeclarativejsast_p.h"

   133 #include "private/qdeclarativejsnodepool_p.h"

   134 

   135 ./

   136 

   137 /:/****************************************************************************

   138 **

   139 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

   140 ** All rights reserved.

   141 ** Contact: Nokia Corporation (qt-info@nokia.com)

   142 **

   143 ** This file is part of the QtDeclarative module of the Qt Toolkit.

   144 **

   145 ** $QT_BEGIN_LICENSE:LGPL$

   146 ** No Commercial Usage

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

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

   149 ** contained in the Technology Preview License Agreement accompanying

   150 ** this package.

   151 **

   152 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

   159 **

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

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

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

   163 **

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

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

   166 **

   167 **

   168 **

   169 **

   170 **

   171 **

   172 **

   173 **

   174 ** $QT_END_LICENSE$

   175 **

   176 ****************************************************************************/

   177 

   178 

   179 //

   180 //  W A R N I N G

   181 //  -------------

   182 //

   183 // This file is not part of the Qt API.  It exists purely as an

   184 // implementation detail.  This header file may change from version to

   185 // version without notice, or even be removed.

   186 //

   187 // We mean it.

   188 //

   189 

   190 //

   191 // This file is automatically generated from qmljs.g.

   192 // Changes will be lost.

   193 //

   194 

   195 #ifndef QDECLARATIVEJSPARSER_P_H

   196 #define QDECLARATIVEJSPARSER_P_H

   197 

   198 #include "private/qdeclarativejsglobal_p.h"

   199 #include "private/qdeclarativejsgrammar_p.h"

   200 #include "private/qdeclarativejsast_p.h"

   201 #include "private/qdeclarativejsengine_p.h"

   202 

   203 #include <QtCore/QList>

   204 #include <QtCore/QString>

   205 

   206 QT_QML_BEGIN_NAMESPACE

   207 

   208 namespace QDeclarativeJS {

   209 

   210 class Engine;

   211 class NameId;

   212 

   213 class QML_PARSER_EXPORT Parser: protected $table

   214 {

   215 public:

   216     union Value {

   217       int ival;

   218       double dval;

   219       NameId *sval;

   220       AST::ArgumentList *ArgumentList;

   221       AST::CaseBlock *CaseBlock;

   222       AST::CaseClause *CaseClause;

   223       AST::CaseClauses *CaseClauses;

   224       AST::Catch *Catch;

   225       AST::DefaultClause *DefaultClause;

   226       AST::ElementList *ElementList;

   227       AST::Elision *Elision;

   228       AST::ExpressionNode *Expression;

   229       AST::Finally *Finally;

   230       AST::FormalParameterList *FormalParameterList;

   231       AST::FunctionBody *FunctionBody;

   232       AST::FunctionDeclaration *FunctionDeclaration;

   233       AST::Node *Node;

   234       AST::PropertyName *PropertyName;

   235       AST::PropertyNameAndValueList *PropertyNameAndValueList;

   236       AST::SourceElement *SourceElement;

   237       AST::SourceElements *SourceElements;

   238       AST::Statement *Statement;

   239       AST::StatementList *StatementList;

   240       AST::Block *Block;

   241       AST::VariableDeclaration *VariableDeclaration;

   242       AST::VariableDeclarationList *VariableDeclarationList;

   243 

   244       AST::UiProgram *UiProgram;

   245       AST::UiImportList *UiImportList;

   246       AST::UiImport *UiImport;

   247       AST::UiParameterList *UiParameterList;

   248       AST::UiPublicMember *UiPublicMember;

   249       AST::UiObjectDefinition *UiObjectDefinition;

   250       AST::UiObjectInitializer *UiObjectInitializer;

   251       AST::UiObjectBinding *UiObjectBinding;

   252       AST::UiScriptBinding *UiScriptBinding;

   253       AST::UiArrayBinding *UiArrayBinding;

   254       AST::UiObjectMember *UiObjectMember;

   255       AST::UiObjectMemberList *UiObjectMemberList;

   256       AST::UiArrayMemberList *UiArrayMemberList;

   257       AST::UiQualifiedId *UiQualifiedId;

   258       AST::UiSignature *UiSignature;

   259       AST::UiFormalList *UiFormalList;

   260       AST::UiFormal *UiFormal;

   261     };

   262 

   263 public:

   264     Parser(Engine *engine);

   265     ~Parser();

   266 

   267     // parse a UI program

   268     bool parse() { return parse(T_FEED_UI_PROGRAM); }

   269     bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }

   270     bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }

   271     bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); }

   272     bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); }

   273     bool parseProgram() { return parse(T_FEED_JS_PROGRAM); }

   274 

   275     AST::UiProgram *ast() const

   276     { return AST::cast<AST::UiProgram *>(program); }

   277 

   278     AST::Statement *statement() const

   279     {

   280         if (! program)

   281             return 0;

   282 

   283         return program->statementCast();

   284     }

   285 

   286     AST::ExpressionNode *expression() const

   287     {

   288         if (! program)

   289             return 0;

   290 

   291         return program->expressionCast();

   292     }

   293 

   294     AST::UiObjectMember *uiObjectMember() const

   295     {

   296         if (! program)

   297             return 0;

   298 

   299         return program->uiObjectMemberCast();

   300     }

   301 

   302     AST::Node *rootNode() const

   303     { return program; }

   304 

   305     QList<DiagnosticMessage> diagnosticMessages() const

   306     { return diagnostic_messages; }

   307 

   308     inline DiagnosticMessage diagnosticMessage() const

   309     {

   310         foreach (const DiagnosticMessage &d, diagnostic_messages) {

   311             if (! d.kind == DiagnosticMessage::Warning)

   312                 return d;

   313         }

   314 

   315         return DiagnosticMessage();

   316     }

   317 

   318     inline QString errorMessage() const

   319     { return diagnosticMessage().message; }

   320 

   321     inline int errorLineNumber() const

   322     { return diagnosticMessage().loc.startLine; }

   323 

   324     inline int errorColumnNumber() const

   325     { return diagnosticMessage().loc.startColumn; }

   326 

   327 protected:

   328     bool parse(int startToken);

   329 

   330     void reallocateStack();

   331 

   332     inline Value &sym(int index)

   333     { return sym_stack [tos + index - 1]; }

   334 

   335     inline AST::SourceLocation &loc(int index)

   336     { return location_stack [tos + index - 1]; }

   337 

   338     AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);

   339 

   340 protected:

   341     Engine *driver;

   342     int tos;

   343     int stack_size;

   344     Value *sym_stack;

   345     int *state_stack;

   346     AST::SourceLocation *location_stack;

   347 

   348     AST::Node *program;

   349 

   350     // error recovery

   351     enum { TOKEN_BUFFER_SIZE = 3 };

   352 

   353     struct SavedToken {

   354        int token;

   355        double dval;

   356        AST::SourceLocation loc;

   357     };

   358 

   359     double yylval;

   360     AST::SourceLocation yylloc;

   361     AST::SourceLocation yyprevlloc;

   362 

   363     SavedToken token_buffer[TOKEN_BUFFER_SIZE];

   364     SavedToken *first_token;

   365     SavedToken *last_token;

   366 

   367     QList<DiagnosticMessage> diagnostic_messages;

   368 };

   369 

   370 } // end of namespace QDeclarativeJS

   371 

   372 

   373 :/

   374 

   375 

   376 /.

   377 

   378 #include "private/qdeclarativejsparser_p.h"

   379 #include <QVarLengthArray>

   380 

   381 //

   382 // This file is automatically generated from qmljs.g.

   383 // Changes will be lost.

   384 //

   385 

   386 using namespace QDeclarativeJS;

   387 

   388 QT_QML_BEGIN_NAMESPACE

   389 

   390 void Parser::reallocateStack()

   391 {

   392     if (! stack_size)

   393         stack_size = 128;

   394     else

   395         stack_size <<= 1;

   396 

   397     sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));

   398     state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));

   399     location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));

   400 }

   401 

   402 inline static bool automatic(Engine *driver, int token)

   403 {

   404     return token == $table::T_RBRACE

   405         || token == 0

   406         || driver->lexer()->prevTerminator();

   407 }

   408 

   409 

   410 Parser::Parser(Engine *engine):

   411     driver(engine),

   412     tos(0),

   413     stack_size(0),

   414     sym_stack(0),

   415     state_stack(0),

   416     location_stack(0),

   417     first_token(0),

   418     last_token(0)

   419 {

   420 }

   421 

   422 Parser::~Parser()

   423 {

   424     if (stack_size) {

   425         qFree(sym_stack);

   426         qFree(state_stack);

   427         qFree(location_stack);

   428     }

   429 }

   430 

   431 static inline AST::SourceLocation location(Lexer *lexer)

   432 {

   433     AST::SourceLocation loc;

   434     loc.offset = lexer->tokenOffset();

   435     loc.length = lexer->tokenLength();

   436     loc.startLine = lexer->startLineNo();

   437     loc.startColumn = lexer->startColumnNo();

   438     return loc;

   439 }

   440 

   441 AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)

   442 {

   443     QVarLengthArray<NameId *, 4> nameIds;

   444     QVarLengthArray<AST::SourceLocation, 4> locations;

   445 

   446     AST::ExpressionNode *it = expr;

   447     while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {

   448         nameIds.append(m->name);

   449         locations.append(m->identifierToken);

   450         it = m->base;

   451     }

   452 

   453     if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {

   454         AST::UiQualifiedId *q = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), idExpr->name);

   455         q->identifierToken = idExpr->identifierToken;

   456 

   457         AST::UiQualifiedId *currentId = q;

   458         for (int i = nameIds.size() - 1; i != -1; --i) {

   459             currentId = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), currentId, nameIds[i]);

   460             currentId->identifierToken = locations[i];

   461         }

   462 

   463         return currentId->finish();

   464     }

   465 

   466     return 0;

   467 }

   468 

   469 bool Parser::parse(int startToken)

   470 {

   471     Lexer *lexer = driver->lexer();

   472     bool hadErrors = false;

   473     int yytoken = -1;

   474     int action = 0;

   475 

   476     token_buffer[0].token = startToken;

   477     first_token = &token_buffer[0];

   478     last_token = &token_buffer[1];

   479 

   480     tos = -1;

   481     program = 0;

   482 

   483     do {

   484         if (++tos == stack_size)

   485             reallocateStack();

   486 

   487         state_stack[tos] = action;

   488 

   489     _Lcheck_token:

   490         if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {

   491             yyprevlloc = yylloc;

   492 

   493             if (first_token == last_token) {

   494                 yytoken = lexer->lex();

   495                 yylval = lexer->dval();

   496                 yylloc = location(lexer);

   497             } else {

   498                 yytoken = first_token->token;

   499                 yylval = first_token->dval;

   500                 yylloc = first_token->loc;

   501                 ++first_token;

   502             }

   503         }

   504 

   505         action = t_action(action, yytoken);

   506         if (action > 0) {

   507             if (action != ACCEPT_STATE) {

   508                 yytoken = -1;

   509                 sym(1).dval = yylval;

   510                 loc(1) = yylloc;

   511             } else {

   512               --tos;

   513               return ! hadErrors;

   514             }

   515         } else if (action < 0) {

   516           const int r = -action - 1;

   517           tos -= rhs[r];

   518 

   519           switch (r) {

   520 ./

   521 

   522 --------------------------------------------------------------------------------------------------------

   523 -- Declarative UI

   524 --------------------------------------------------------------------------------------------------------

   525 

   526 TopLevel: T_FEED_UI_PROGRAM UiProgram ;

   527 /.

   528 case $rule_number: {

   529   sym(1).Node = sym(2).Node;

   530   program = sym(1).Node;

   531 } break;

   532 ./

   533 

   534 TopLevel: T_FEED_JS_STATEMENT Statement ;

   535 /.

   536 case $rule_number: {

   537   sym(1).Node = sym(2).Node;

   538   program = sym(1).Node;

   539 } break;

   540 ./

   541 

   542 TopLevel: T_FEED_JS_EXPRESSION Expression ;

   543 /.

   544 case $rule_number: {

   545   sym(1).Node = sym(2).Node;

   546   program = sym(1).Node;

   547 } break;

   548 ./

   549 

   550 TopLevel: T_FEED_JS_SOURCE_ELEMENT SourceElement ;

   551 /.

   552 case $rule_number: {

   553   sym(1).Node = sym(2).Node;

   554   program = sym(1).Node;

   555 } break;

   556 ./

   557 

   558 TopLevel: T_FEED_UI_OBJECT_MEMBER UiObjectMember ;

   559 /.

   560 case $rule_number: {

   561   sym(1).Node = sym(2).Node;

   562   program = sym(1).Node;

   563 } break;

   564 ./

   565 

   566 TopLevel: T_FEED_JS_PROGRAM Program ;

   567 /.

   568 case $rule_number: {

   569   sym(1).Node = sym(2).Node;

   570   program = sym(1).Node;

   571 } break;

   572 ./

   573 

   574 UiProgram: UiImportListOpt UiRootMember ;

   575 /.

   576 case $rule_number: {

   577   sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList,

   578         sym(2).UiObjectMemberList->finish());

   579 } break;

   580 ./

   581 

   582 UiImportListOpt: Empty ;

   583 UiImportListOpt: UiImportList ;

   584 /.

   585 case $rule_number: {

   586     sym(1).Node = sym(1).UiImportList->finish();

   587 } break;

   588 ./

   589 

   590 UiImportList: UiImport ;

   591 /.

   592 case $rule_number: {

   593     sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport);

   594 } break;

   595 ./

   596 

   597 UiImportList: UiImportList UiImport ;

   598 /.

   599 case $rule_number: {

   600     sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(),

   601         sym(1).UiImportList, sym(2).UiImport);

   602 } break;

   603 ./

   604 

   605 ImportId: MemberExpression ;

   606 

   607 UiImport: UiImportHead T_AUTOMATIC_SEMICOLON ;

   608 UiImport: UiImportHead T_SEMICOLON ;

   609 /.

   610 case $rule_number: {

   611     sym(1).UiImport->semicolonToken = loc(2);

   612 } break;

   613 ./

   614 

   615 UiImport: UiImportHead T_NUMERIC_LITERAL T_AUTOMATIC_SEMICOLON ;

   616 UiImport: UiImportHead T_NUMERIC_LITERAL T_SEMICOLON ;

   617 /.

   618 case $rule_number: {

   619     sym(1).UiImport->versionToken = loc(2);

   620     sym(1).UiImport->semicolonToken = loc(3);

   621 } break;

   622 ./

   623 

   624 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;

   625 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_SEMICOLON ;

   626 /.

   627 case $rule_number: {

   628     sym(1).UiImport->versionToken = loc(2);

   629     sym(1).UiImport->asToken = loc(3);

   630     sym(1).UiImport->importIdToken = loc(4);

   631     sym(1).UiImport->importId = sym(4).sval;

   632     sym(1).UiImport->semicolonToken = loc(5);

   633 } break;

   634 ./

   635 

   636 UiImport: UiImportHead T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;

   637 UiImport: UiImportHead T_AS JsIdentifier T_SEMICOLON ;

   638 /.

   639 case $rule_number: {

   640     sym(1).UiImport->asToken = loc(2);

   641     sym(1).UiImport->importIdToken = loc(3);

   642     sym(1).UiImport->importId = sym(3).sval;

   643     sym(1).UiImport->semicolonToken = loc(4);

   644 } break;

   645 ./

   646 

   647 

   648 UiImportHead: T_IMPORT ImportId ;

   649 /.

   650 case $rule_number: {

   651     AST::UiImport *node = 0;

   652 

   653     if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {

   654         node = makeAstNode<AST::UiImport>(driver->nodePool(), importIdLiteral->value);

   655         node->fileNameToken = loc(2);

   656     } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {

   657         node = makeAstNode<AST::UiImport>(driver->nodePool(), qualifiedId);

   658         node->fileNameToken = loc(2);

   659     }

   660 

   661     sym(1).Node = node;

   662 

   663     if (node) {

   664         node->importToken = loc(1);

   665     } else {

   666        diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),

   667          QLatin1String("Expected a qualified name id or a string literal")));

   668 

   669         return false; // ### remove me

   670     }

   671 } break;

   672 ./

   673 

   674 Empty: ;

   675 /.

   676 case $rule_number: {

   677     sym(1).Node = 0;

   678 } break;

   679 ./

   680 

   681 UiRootMember: UiObjectDefinition ;

   682 /.

   683 case $rule_number: {

   684     sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);

   685 } break;

   686 ./

   687 

   688 UiObjectMemberList: UiObjectMember ;

   689 /.

   690 case $rule_number: {

   691     sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);

   692 } break;

   693 ./

   694 

   695 UiObjectMemberList: UiObjectMemberList UiObjectMember ;

   696 /.

   697 case $rule_number: {

   698     AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(),

   699         sym(1).UiObjectMemberList, sym(2).UiObjectMember);

   700     sym(1).Node = node;

   701 } break;

   702 ./

   703 

   704 UiArrayMemberList: UiObjectDefinition ;

   705 /.

   706 case $rule_number: {

   707     sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember);

   708 } break;

   709 ./

   710 

   711 UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ;

   712 /.

   713 case $rule_number: {

   714     AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(),

   715         sym(1).UiArrayMemberList, sym(3).UiObjectMember);

   716     node->commaToken = loc(2);

   717     sym(1).Node = node;

   718 } break;

   719 ./

   720 

   721 UiObjectInitializer: T_LBRACE T_RBRACE ;

   722 /.

   723 case $rule_number: {

   724     AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0);

   725     node->lbraceToken = loc(1);

   726     node->rbraceToken = loc(2);

   727     sym(1).Node = node;

   728 }   break;

   729 ./

   730 

   731 UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ;

   732 /.

   733 case $rule_number: {

   734     AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), sym(2).UiObjectMemberList->finish());

   735     node->lbraceToken = loc(1);

   736     node->rbraceToken = loc(3);

   737     sym(1).Node = node;

   738 }   break;

   739 ./

   740 

   741 UiObjectDefinition: UiQualifiedId UiObjectInitializer ;

   742 /.

   743 case $rule_number: {

   744     AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId,

   745         sym(2).UiObjectInitializer);

   746     sym(1).Node = node;

   747 }   break;

   748 ./

   749 

   750 UiObjectMember: UiObjectDefinition ;

   751 

   752 UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;

   753 /.

   754 case $rule_number: {

   755     AST::UiArrayBinding *node = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),

   756         sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());

   757     node->colonToken = loc(2);

   758     node->lbracketToken = loc(3);

   759     node->rbracketToken = loc(5);

   760     sym(1).Node = node;

   761 }   break;

   762 ./

   763 

   764 UiObjectMember: UiQualifiedId             T_COLON UiQualifiedId  UiObjectInitializer ;

   765 /.

   766 case $rule_number: {

   767     AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),

   768       sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);

   769     node->colonToken = loc(2);

   770     sym(1).Node = node;

   771 } break;

   772 ./

   773 

   774 UiObjectMember: UiQualifiedId             T_ON UiQualifiedId  UiObjectInitializer ;

   775 /.

   776 case $rule_number: {

   777     AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),

   778       sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);

   779     node->colonToken = loc(2);

   780     node->hasOnToken = true;

   781     sym(1).Node = node;

   782 } break;

   783 ./

   784 

   785 UiObjectMember: UiQualifiedId T_COLON Block ;

   786 /.case $rule_number:./

   787 

   788 UiObjectMember: UiQualifiedId T_COLON EmptyStatement ;

   789 /.case $rule_number:./

   790 

   791 UiObjectMember: UiQualifiedId T_COLON ExpressionStatement ;

   792 /.case $rule_number:./

   793 

   794 UiObjectMember: UiQualifiedId T_COLON IfStatement ; --- ### do we really want if statement in a binding?

   795 /.case $rule_number:./

   796 

   797 /.

   798 {

   799     AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(),

   800         sym(1).UiQualifiedId, sym(3).Statement);

   801     node->colonToken = loc(2);

   802     sym(1).Node = node;

   803 }   break;

   804 ./

   805 

   806 UiPropertyType: T_VAR ;

   807 /.

   808 case $rule_number:

   809 ./

   810 UiPropertyType: T_RESERVED_WORD ;

   811 /.

   812 case $rule_number: {

   813     sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());

   814     break;

   815 }

   816 ./

   817 

   818 UiPropertyType: T_IDENTIFIER ;

   819 

   820 UiParameterListOpt: ;

   821 /.

   822 case $rule_number: {

   823   sym(1).Node = 0;

   824 } break;

   825 ./

   826 

   827 UiParameterListOpt: UiParameterList ;

   828 /.

   829 case $rule_number: {

   830   sym(1).Node = sym(1).UiParameterList->finish ();

   831 } break;

   832 ./

   833 

   834 UiParameterList: UiPropertyType JsIdentifier ;

   835 /.

   836 case $rule_number: {

   837   AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval);

   838   node->identifierToken = loc(2);

   839   sym(1).Node = node;

   840 } break;

   841 ./

   842 

   843 UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ;

   844 /.

   845 case $rule_number: {

   846   AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).UiParameterList, sym(3).sval, sym(4).sval);

   847   node->commaToken = loc(2);

   848   node->identifierToken = loc(4);

   849   sym(1).Node = node;

   850 } break;

   851 ./

   852 

   853 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_AUTOMATIC_SEMICOLON ;

   854 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ;

   855 /.

   856 case $rule_number: {

   857     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);

   858     node->type = AST::UiPublicMember::Signal;

   859     node->propertyToken = loc(1);

   860     node->typeToken = loc(2);

   861     node->identifierToken = loc(2);

   862     node->parameters = sym(4).UiParameterList;

   863     node->semicolonToken = loc(6);

   864     sym(1).Node = node;

   865 }   break;

   866 ./

   867 

   868 UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;

   869 UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ;

   870 /.

   871 case $rule_number: {

   872     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);

   873     node->type = AST::UiPublicMember::Signal;

   874     node->propertyToken = loc(1);

   875     node->typeToken = loc(2);

   876     node->identifierToken = loc(2);

   877     node->semicolonToken = loc(3);

   878     sym(1).Node = node;

   879 }   break;

   880 ./

   881 

   882 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_AUTOMATIC_SEMICOLON ;

   883 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ;

   884 /.

   885 case $rule_number: {

   886     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);

   887     node->typeModifier = sym(2).sval;

   888     node->propertyToken = loc(1);

   889     node->typeModifierToken = loc(2);

   890     node->typeToken = loc(4);

   891     node->identifierToken = loc(6);

   892     node->semicolonToken = loc(7);

   893     sym(1).Node = node;

   894 }   break;

   895 ./

   896 

   897 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;

   898 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;

   899 /.

   900 case $rule_number: {

   901     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);

   902     node->propertyToken = loc(1);

   903     node->typeToken = loc(2);

   904     node->identifierToken = loc(3);

   905     node->semicolonToken = loc(4);

   906     sym(1).Node = node;

   907 }   break;

   908 ./

   909 

   910 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;

   911 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;

   912 /.

   913 case $rule_number: {

   914     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval);

   915     node->isDefaultMember = true;

   916     node->defaultToken = loc(1);

   917     node->propertyToken = loc(2);

   918     node->typeToken = loc(3);

   919     node->identifierToken = loc(4);

   920     node->semicolonToken = loc(5);

   921     sym(1).Node = node;

   922 }   break;

   923 ./

   924 

   925 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;

   926 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;

   927 /.

   928 case $rule_number: {

   929     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval,

   930         sym(5).Expression);

   931     node->propertyToken = loc(1);

   932     node->typeToken = loc(2);

   933     node->identifierToken = loc(3);

   934     node->colonToken = loc(4);

   935     node->semicolonToken = loc(6);

   936     sym(1).Node = node;

   937 }   break;

   938 ./

   939 

   940 UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;

   941 UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;

   942 /.

   943 case $rule_number: {

   944     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,

   945         sym(6).Expression);

   946     node->isReadonlyMember = true;

   947     node->readonlyToken = loc(1);

   948     node->propertyToken = loc(2);

   949     node->typeToken = loc(3);

   950     node->identifierToken = loc(4);

   951     node->colonToken = loc(5);

   952     node->semicolonToken = loc(7);

   953     sym(1).Node = node;

   954 }   break;

   955 ./

   956 

   957 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;

   958 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;

   959 /.

   960 case $rule_number: {

   961     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,

   962         sym(6).Expression);

   963     node->isDefaultMember = true;

   964     node->defaultToken = loc(1);

   965     node->propertyToken = loc(2);

   966     node->typeToken = loc(3);

   967     node->identifierToken = loc(4);

   968     node->colonToken = loc(5);

   969     node->semicolonToken = loc(7);

   970     sym(1).Node = node;

   971 }   break;

   972 ./

   973 

   974 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;

   975 /.

   976 case $rule_number: {

   977     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);

   978     node->typeModifier = sym(2).sval;

   979     node->propertyToken = loc(1);

   980     node->typeModifierToken = loc(2);

   981     node->typeToken = loc(4);

   982     node->identifierToken = loc(6);

   983     node->semicolonToken = loc(7); // insert a fake ';' before ':'

   984 

   985     AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(6).sval);

   986     propertyName->identifierToken = loc(6);

   987     propertyName->next = 0;

   988 

   989     AST::UiArrayBinding *binding = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),

   990         propertyName, sym(9).UiArrayMemberList->finish());

   991     binding->colonToken = loc(7);

   992     binding->lbracketToken = loc(8);

   993     binding->rbracketToken = loc(10);

   994 

   995     node->binding = binding;

   996 

   997     sym(1).Node = node;

   998 }   break;

   999 ./

  1000 

  1001 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ;

  1002 /.

  1003 case $rule_number: {

  1004     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);

  1005     node->propertyToken = loc(1);

  1006     node->typeToken = loc(2);

  1007     node->identifierToken = loc(3);

  1008     node->semicolonToken = loc(4); // insert a fake ';' before ':'

  1009 

  1010     AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(3).sval);

  1011     propertyName->identifierToken = loc(3);

  1012     propertyName->next = 0;

  1013 

  1014     AST::UiObjectBinding *binding = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),

  1015       propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);

  1016     binding->colonToken = loc(4);

  1017 

  1018     node->binding = binding;

  1019 

  1020     sym(1).Node = node;

  1021 }   break;

  1022 ./

  1023 

  1024 UiObjectMember: FunctionDeclaration ;

  1025 /.

  1026 case $rule_number: {

  1027     sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);

  1028 }   break;

  1029 ./

  1030 

  1031 UiObjectMember: VariableStatement ;

  1032 /.

  1033 case $rule_number: {

  1034     sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);

  1035 }   break;

  1036 ./

  1037 

  1038 JsIdentifier: T_IDENTIFIER;

  1039 

  1040 JsIdentifier: T_PROPERTY ;

  1041 /.

  1042 case $rule_number: {

  1043     QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_PROPERTY]);

  1044     sym(1).sval = driver->intern(s.constData(), s.length());

  1045     break;

  1046 }

  1047 ./

  1048 

  1049 JsIdentifier: T_SIGNAL ;

  1050 /.

  1051 case $rule_number: {

  1052     QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_SIGNAL]);

  1053     sym(1).sval = driver->intern(s.constData(), s.length());

  1054     break;

  1055 }

  1056 ./

  1057 

  1058 JsIdentifier: T_READONLY ;

  1059 /.

  1060 case $rule_number: {

  1061     QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_READONLY]);

  1062     sym(1).sval = driver->intern(s.constData(), s.length());

  1063     break;

  1064 }

  1065 ./

  1066 

  1067 JsIdentifier: T_ON ;

  1068 /.

  1069 case $rule_number: {

  1070     QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_ON]);

  1071     sym(1).sval = driver->intern(s.constData(), s.length());

  1072     break;

  1073 }

  1074 ./

  1075 

  1076 --------------------------------------------------------------------------------------------------------

  1077 -- Expressions

  1078 --------------------------------------------------------------------------------------------------------

  1079 

  1080 PrimaryExpression: T_THIS ;

  1081 /.

  1082 case $rule_number: {

  1083   AST::ThisExpression *node = makeAstNode<AST::ThisExpression> (driver->nodePool());

  1084   node->thisToken = loc(1);

  1085   sym(1).Node = node;

  1086 } break;

  1087 ./

  1088 

  1089 PrimaryExpression: JsIdentifier ;

  1090 /.

  1091 case $rule_number: {

  1092   AST::IdentifierExpression *node = makeAstNode<AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);

  1093   node->identifierToken = loc(1);

  1094   sym(1).Node = node;

  1095 } break;

  1096 ./

  1097 

  1098 PrimaryExpression: T_NULL ;

  1099 /.

  1100 case $rule_number: {

  1101   AST::NullExpression *node = makeAstNode<AST::NullExpression> (driver->nodePool());

  1102   node->nullToken = loc(1);

  1103   sym(1).Node = node;

  1104 } break;

  1105 ./

  1106 

  1107 PrimaryExpression: T_TRUE ;

  1108 /.

  1109 case $rule_number: {

  1110   AST::TrueLiteral *node = makeAstNode<AST::TrueLiteral> (driver->nodePool());

  1111   node->trueToken = loc(1);

  1112   sym(1).Node = node;

  1113 } break;

  1114 ./

  1115 

  1116 PrimaryExpression: T_FALSE ;

  1117 /.

  1118 case $rule_number: {

  1119   AST::FalseLiteral *node = makeAstNode<AST::FalseLiteral> (driver->nodePool());

  1120   node->falseToken = loc(1);

  1121   sym(1).Node = node;

  1122 } break;

  1123 ./

  1124 

  1125 PrimaryExpression: T_NUMERIC_LITERAL ;

  1126 /.

  1127 case $rule_number: {

  1128   AST::NumericLiteral *node = makeAstNode<AST::NumericLiteral> (driver->nodePool(), sym(1).dval);

  1129   node->literalToken = loc(1);

  1130   sym(1).Node = node;

  1131 } break;

  1132 ./

  1133 

  1134 PrimaryExpression: T_MULTILINE_STRING_LITERAL ;