src/libs/qmljs/parser/qmljs.g

   1 ----------------------------------------------------------------------------
   2 --
   3 -- This file is part of Qt Creator
   4 --
   5 -- Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 --
   7 -- Contact: Nokia Corporation (info@qt.nokia.com)
   8 --
   9 -- GNU Lesser General Public License Usage
  10 --
  11 -- This file may be used under the terms of the GNU Lesser General Public
  12 -- License version 2.1 as published by the Free Software Foundation and
  13 -- appearing in the file LICENSE.LGPL included in the packaging of this file.
  14 -- Please review the following information to ensure the GNU Lesser General
  15 -- Public License version 2.1 requirements will be met:
  16 -- http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 --
  18 -- In addition, as a special exception, Nokia gives you certain additional
  19 -- rights. These rights are described in the Nokia Qt LGPL Exception
  20 -- version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 --
  22 -- Other Usage
  23 --
  24 -- Alternatively, this file may be used in accordance with the terms and
  25 -- conditions contained in a signed written agreement between you and Nokia.
  26 --
  27 -- If you have questions regarding the use of this file, please contact
  28 -- Nokia at qt-info@nokia.com.
  29 --
  30 ----------------------------------------------------------------------------
  31
  32 %parser         QmlJSGrammar
  33 %decl           qmljsparser_p.h
  34 %impl           qmljsparser.cpp
  35 %expect         2
  36 %expect-rr      2
  37
  38 %token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="
  39 %token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"
  40 %token T_COLON ":"              T_COMMA ";"                 T_CONTINUE "continue"
  41 %token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"
  42 %token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."
  43 %token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="
  44 %token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"
  45 %token T_FUNCTION "function"    T_GE ">="                   T_GT ">"
  46 %token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"
  47 %token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"
  48 %token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"
  49 %token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("
  50 %token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="
  51 %token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"
  52 %token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="
  53 %token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"
  54 %token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"
  55 %token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"
  56 %token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"
  57 %token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"
  58 %token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"
  59 %token T_STAR_EQ "*="           T_STRING_LITERAL "string literal"
  60 %token T_PROPERTY "property"    T_SIGNAL "signal"           T_READONLY "readonly"
  61 %token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"
  62 %token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"
  63 %token T_VAR "var"              T_VOID "void"               T_WHILE "while"
  64 %token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="
  65 %token T_NULL "null"            T_TRUE "true"               T_FALSE "false"
  66 %token T_CONST "const"
  67 %token T_DEBUGGER "debugger"
  68 %token T_RESERVED_WORD "reserved word"
  69 %token T_MULTILINE_STRING_LITERAL "multiline string literal"
  70 %token T_COMMENT "comment"
  71
  72 --- context keywords.
  73 %token T_PUBLIC "public"
  74 %token T_IMPORT "import"
  75 %token T_AS "as"
  76 %token T_ON "on"
  77
  78 --- feed tokens
  79 %token T_FEED_UI_PROGRAM
  80 %token T_FEED_UI_OBJECT_MEMBER
  81 %token T_FEED_JS_STATEMENT
  82 %token T_FEED_JS_EXPRESSION
  83 %token T_FEED_JS_SOURCE_ELEMENT
  84 %token T_FEED_JS_PROGRAM
  85
  86 %nonassoc SHIFT_THERE
  87 %nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY
  88 %nonassoc REDUCE_HERE
  89
  90 %start TopLevel
  91
  92 /./**************************************************************************
  93 **
  94 ** This file is part of Qt Creator
  95 **
  96 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
  97 **
  98 ** Contact: Nokia Corporation (info@qt.nokia.com)
  99 **
 100 ** GNU Lesser General Public License Usage
 101 **
 102 ** This file may be used under the terms of the GNU Lesser General Public
 103 ** License version 2.1 as published by the Free Software Foundation and
 104 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
 105 ** Please review the following information to ensure the GNU Lesser General
 106 ** Public License version 2.1 requirements will be met:
 107 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 108 **
 109 ** In addition, as a special exception, Nokia gives you certain additional
 110 ** rights. These rights are described in the Nokia Qt LGPL Exception
 111 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 112 **
 113 ** Other Usage
 114 **
 115 ** Alternatively, this file may be used in accordance with the terms and
 116 ** conditions contained in a signed written agreement between you and Nokia.
 117 **
 118 ** If you have questions regarding the use of this file, please contact
 119 ** Nokia at qt-info@nokia.com.
 120 **
 121 **************************************************************************/
 122
 123
 124 #include <QtCore/QtDebug>
 125 #include <QtGui/QApplication>
 126
 127 #include <string.h>
 128
 129 #include "qmljsengine_p.h"
 130 #include "qmljslexer_p.h"
 131 #include "qmljsast_p.h"
 132 #include "qmljsnodepool_p.h"
 133
 134 ./
 135
 136 /:/**************************************************************************
 137 **
 138 ** This file is part of Qt Creator
 139 **
 140 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
 141 **
 142 ** Contact: Nokia Corporation (info@qt.nokia.com)
 143 **
 144 ** GNU Lesser General Public License Usage
 145 **
 146 ** This file may be used under the terms of the GNU Lesser General Public
 147 ** License version 2.1 as published by the Free Software Foundation and
 148 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
 149 ** Please review the following information to ensure the GNU Lesser General
 150 ** Public License version 2.1 requirements will be met:
 151 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 152 **
 153 ** In addition, as a special exception, Nokia gives you certain additional
 154 ** rights. These rights are described in the Nokia Qt LGPL Exception
 155 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 156 **
 157 ** Other Usage
 158 **
 159 ** Alternatively, this file may be used in accordance with the terms and
 160 ** conditions contained in a signed written agreement between you and Nokia.
 161 **
 162 ** If you have questions regarding the use of this file, please contact
 163 ** Nokia at qt-info@nokia.com.
 164 **
 165 **************************************************************************/
 166
 167
 168
 169 //
 170 //  W A R N I N G
 171 //  -------------
 172 //
 173 // This file is not part of the Qt API.  It exists purely as an
 174 // implementation detail.  This header file may change from version to
 175 // version without notice, or even be removed.
 176 //
 177 // We mean it.
 178 //
 179
 180 //
 181 // This file is automatically generated from qmljs.g.
 182 // Changes will be lost.
 183 //
 184
 185 #ifndef QMLJSPARSER_P_H
 186 #define QMLJSPARSER_P_H
 187
 188 #include "qmljsglobal_p.h"
 189 #include "qmljsgrammar_p.h"
 190 #include "qmljsast_p.h"
 191 #include "qmljsengine_p.h"
 192
 193 #include <QtCore/QList>
 194 #include <QtCore/QString>
 195
 196 QT_QML_BEGIN_NAMESPACE
 197
 198 namespace QmlJS {
 199
 200 class Engine;
 201 class NameId;
 202
 203 class QML_PARSER_EXPORT Parser: protected $table
 204 {
 205 public:
 206     union Value {
 207       int ival;
 208       double dval;
 209       NameId *sval;
 210       AST::ArgumentList *ArgumentList;
 211       AST::CaseBlock *CaseBlock;
 212       AST::CaseClause *CaseClause;
 213       AST::CaseClauses *CaseClauses;
 214       AST::Catch *Catch;
 215       AST::DefaultClause *DefaultClause;
 216       AST::ElementList *ElementList;
 217       AST::Elision *Elision;
 218       AST::ExpressionNode *Expression;
 219       AST::Finally *Finally;
 220       AST::FormalParameterList *FormalParameterList;
 221       AST::FunctionBody *FunctionBody;
 222       AST::FunctionDeclaration *FunctionDeclaration;
 223       AST::Node *Node;
 224       AST::PropertyName *PropertyName;
 225       AST::PropertyNameAndValueList *PropertyNameAndValueList;
 226       AST::SourceElement *SourceElement;
 227       AST::SourceElements *SourceElements;
 228       AST::Statement *Statement;
 229       AST::StatementList *StatementList;
 230       AST::Block *Block;
 231       AST::VariableDeclaration *VariableDeclaration;
 232       AST::VariableDeclarationList *VariableDeclarationList;
 233
 234       AST::UiProgram *UiProgram;
 235       AST::UiImportList *UiImportList;
 236       AST::UiImport *UiImport;
 237       AST::UiParameterList *UiParameterList;
 238       AST::UiPublicMember *UiPublicMember;
 239       AST::UiObjectDefinition *UiObjectDefinition;
 240       AST::UiObjectInitializer *UiObjectInitializer;
 241       AST::UiObjectBinding *UiObjectBinding;
 242       AST::UiScriptBinding *UiScriptBinding;
 243       AST::UiArrayBinding *UiArrayBinding;
 244       AST::UiObjectMember *UiObjectMember;
 245       AST::UiObjectMemberList *UiObjectMemberList;
 246       AST::UiArrayMemberList *UiArrayMemberList;
 247       AST::UiQualifiedId *UiQualifiedId;
 248       AST::UiSignature *UiSignature;
 249       AST::UiFormalList *UiFormalList;
 250       AST::UiFormal *UiFormal;
 251     };
 252
 253 public:
 254     Parser(Engine *engine);
 255     ~Parser();
 256
 257     // parse a UI program
 258     bool parse() { return parse(T_FEED_UI_PROGRAM); }
 259     bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }
 260     bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }
 261     bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); }
 262     bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); }
 263     bool parseProgram() { return parse(T_FEED_JS_PROGRAM); }
 264
 265     AST::UiProgram *ast() const
 266     { return AST::cast<AST::UiProgram *>(program); }
 267
 268     AST::Statement *statement() const
 269     {
 270         if (! program)
 271             return 0;
 272
 273         return program->statementCast();
 274     }
 275
 276     AST::ExpressionNode *expression() const
 277     {
 278         if (! program)
 279             return 0;
 280
 281         return program->expressionCast();
 282     }
 283
 284     AST::UiObjectMember *uiObjectMember() const
 285     {
 286         if (! program)
 287             return 0;
 288
 289         return program->uiObjectMemberCast();
 290     }
 291
 292     AST::Node *rootNode() const
 293     { return program; }
 294
 295     QList<DiagnosticMessage> diagnosticMessages() const
 296     { return diagnostic_messages; }
 297
 298     inline DiagnosticMessage diagnosticMessage() const
 299     {
 300         foreach (const DiagnosticMessage &d, diagnostic_messages) {
 301             if (! d.kind == DiagnosticMessage::Warning)
 302                 return d;
 303         }
 304
 305         return DiagnosticMessage();
 306     }
 307
 308     inline QString errorMessage() const
 309     { return diagnosticMessage().message; }
 310
 311     inline int errorLineNumber() const
 312     { return diagnosticMessage().loc.startLine; }
 313
 314     inline int errorColumnNumber() const
 315     { return diagnosticMessage().loc.startColumn; }
 316
 317 protected:
 318     bool parse(int startToken);
 319
 320     void reallocateStack();
 321
 322     inline Value &sym(int index)
 323     { return sym_stack [tos + index - 1]; }
 324
 325     inline AST::SourceLocation &loc(int index)
 326     { return location_stack [tos + index - 1]; }
 327
 328     AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);
 329
 330 protected:
 331     Engine *driver;
 332     int tos;
 333     int stack_size;
 334     Value *sym_stack;
 335     int *state_stack;
 336     AST::SourceLocation *location_stack;
 337
 338     AST::Node *program;
 339
 340     // error recovery
 341     enum { TOKEN_BUFFER_SIZE = 3 };
 342
 343     struct SavedToken {
 344        int token;
 345        double dval;
 346        AST::SourceLocation loc;
 347     };
 348
 349     double yylval;
 350     AST::SourceLocation yylloc;
 351     AST::SourceLocation yyprevlloc;
 352
 353     SavedToken token_buffer[TOKEN_BUFFER_SIZE];
 354     SavedToken *first_token;
 355     SavedToken *last_token;
 356
 357     QList<DiagnosticMessage> diagnostic_messages;
 358 };
 359
 360 } // end of namespace QmlJS
 361
 362
 363 :/
 364
 365
 366 /.
 367
 368 #include "qmljsparser_p.h"
 369 #include <QVarLengthArray>
 370
 371 //
 372 // This file is automatically generated from qmljs.g.
 373 // Changes will be lost.
 374 //
 375
 376 using namespace QmlJS;
 377
 378 QT_QML_BEGIN_NAMESPACE
 379
 380 void Parser::reallocateStack()
 381 {
 382     if (! stack_size)
 383         stack_size = 128;
 384     else
 385         stack_size <<= 1;
 386
 387     sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
 388     state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
 389     location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
 390 }
 391
 392 inline static bool automatic(Engine *driver, int token)
 393 {
 394     return token == $table::T_RBRACE
 395         || token == 0
 396         || driver->lexer()->prevTerminator();
 397 }
 398
 399
 400 Parser::Parser(Engine *engine):
 401     driver(engine),
 402     tos(0),
 403     stack_size(0),
 404     sym_stack(0),
 405     state_stack(0),
 406     location_stack(0),
 407     first_token(0),
 408     last_token(0)
 409 {
 410 }
 411
 412 Parser::~Parser()
 413 {
 414     if (stack_size) {
 415         qFree(sym_stack);
 416         qFree(state_stack);
 417         qFree(location_stack);
 418     }
 419 }
 420
 421 static inline AST::SourceLocation location(Lexer *lexer)
 422 {
 423     AST::SourceLocation loc;
 424     loc.offset = lexer->tokenOffset();
 425     loc.length = lexer->tokenLength();
 426     loc.startLine = lexer->startLineNo();
 427     loc.startColumn = lexer->startColumnNo();
 428     return loc;
 429 }
 430
 431 AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
 432 {
 433     QVarLengthArray<NameId *, 4> nameIds;
 434     QVarLengthArray<AST::SourceLocation, 4> locations;
 435
 436     AST::ExpressionNode *it = expr;
 437     while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
 438         nameIds.append(m->name);
 439         locations.append(m->identifierToken);
 440         it = m->base;
 441     }
 442
 443     if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
 444         AST::UiQualifiedId *q = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), idExpr->name);
 445         q->identifierToken = idExpr->identifierToken;
 446
 447         AST::UiQualifiedId *currentId = q;
 448         for (int i = nameIds.size() - 1; i != -1; --i) {
 449             currentId = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), currentId, nameIds[i]);
 450             currentId->identifierToken = locations[i];
 451         }
 452
 453         return currentId->finish();
 454     }
 455
 456     return 0;
 457 }
 458
 459 bool Parser::parse(int startToken)
 460 {
 461     Lexer *lexer = driver->lexer();
 462     bool hadErrors = false;
 463     int yytoken = -1;
 464     int action = 0;
 465
 466     token_buffer[0].token = startToken;
 467     first_token = &token_buffer[0];
 468     last_token = &token_buffer[1];
 469
 470     tos = -1;
 471     program = 0;
 472
 473     do {
 474         if (++tos == stack_size)
 475             reallocateStack();
 476
 477         state_stack[tos] = action;
 478
 479     _Lcheck_token:
 480         if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
 481             yyprevlloc = yylloc;
 482
 483             if (first_token == last_token) {
 484                 yytoken = lexer->lex();
 485                 yylval = lexer->dval();
 486                 yylloc = location(lexer);
 487             } else {
 488                 yytoken = first_token->token;
 489                 yylval = first_token->dval;
 490                 yylloc = first_token->loc;
 491                 ++first_token;
 492             }
 493         }
 494
 495         action = t_action(action, yytoken);
 496         if (action > 0) {
 497             if (action != ACCEPT_STATE) {
 498                 yytoken = -1;
 499                 sym(1).dval = yylval;
 500                 loc(1) = yylloc;
 501             } else {
 502               --tos;
 503               return ! hadErrors;
 504             }
 505         } else if (action < 0) {
 506           const int r = -action - 1;
 507           tos -= rhs[r];
 508
 509           switch (r) {
 510 ./
 511
 512 --------------------------------------------------------------------------------------------------------
 513 -- Declarative UI
 514 --------------------------------------------------------------------------------------------------------
 515
 516 TopLevel: T_FEED_UI_PROGRAM UiProgram ;
 517 /.
 518 case $rule_number: {
 519   sym(1).Node = sym(2).Node;
 520   program = sym(1).Node;
 521 } break;
 522 ./
 523
 524 TopLevel: T_FEED_JS_STATEMENT Statement ;
 525 /.
 526 case $rule_number: {
 527   sym(1).Node = sym(2).Node;
 528   program = sym(1).Node;
 529 } break;
 530 ./
 531
 532 TopLevel: T_FEED_JS_EXPRESSION Expression ;
 533 /.
 534 case $rule_number: {
 535   sym(1).Node = sym(2).Node;
 536   program = sym(1).Node;
 537 } break;
 538 ./
 539
 540 TopLevel: T_FEED_JS_SOURCE_ELEMENT SourceElement ;
 541 /.
 542 case $rule_number: {
 543   sym(1).Node = sym(2).Node;
 544   program = sym(1).Node;
 545 } break;
 546 ./
 547
 548 TopLevel: T_FEED_UI_OBJECT_MEMBER UiObjectMember ;
 549 /.
 550 case $rule_number: {
 551   sym(1).Node = sym(2).Node;
 552   program = sym(1).Node;
 553 } break;
 554 ./
 555
 556 TopLevel: T_FEED_JS_PROGRAM Program ;
 557 /.
 558 case $rule_number: {
 559   sym(1).Node = sym(2).Node;
 560   program = sym(1).Node;
 561 } break;
 562 ./
 563
 564 UiProgram: UiImportListOpt UiRootMember ;
 565 /.
 566 case $rule_number: {
 567   sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList,
 568         sym(2).UiObjectMemberList->finish());
 569 } break;
 570 ./
 571
 572 UiImportListOpt: Empty ;
 573 UiImportListOpt: UiImportList ;
 574 /.
 575 case $rule_number: {
 576     sym(1).Node = sym(1).UiImportList->finish();
 577 } break;
 578 ./
 579
 580 UiImportList: UiImport ;
 581 /.
 582 case $rule_number: {
 583     sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport);
 584 } break;
 585 ./
 586
 587 UiImportList: UiImportList UiImport ;
 588 /.
 589 case $rule_number: {
 590     sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(),
 591         sym(1).UiImportList, sym(2).UiImport);
 592 } break;
 593 ./
 594
 595 ImportId: MemberExpression ;
 596
 597 UiImport: UiImportHead T_AUTOMATIC_SEMICOLON ;
 598 UiImport: UiImportHead T_SEMICOLON ;
 599 /.
 600 case $rule_number: {
 601     sym(1).UiImport->semicolonToken = loc(2);
 602 } break;
 603 ./
 604
 605 UiImport: UiImportHead T_NUMERIC_LITERAL T_AUTOMATIC_SEMICOLON ;
 606 UiImport: UiImportHead T_NUMERIC_LITERAL T_SEMICOLON ;
 607 /.
 608 case $rule_number: {
 609     sym(1).UiImport->versionToken = loc(2);
 610     sym(1).UiImport->semicolonToken = loc(3);
 611 } break;
 612 ./
 613
 614 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
 615 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_SEMICOLON ;
 616 /.
 617 case $rule_number: {
 618     sym(1).UiImport->versionToken = loc(2);
 619     sym(1).UiImport->asToken = loc(3);
 620     sym(1).UiImport->importIdToken = loc(4);
 621     sym(1).UiImport->importId = sym(4).sval;
 622     sym(1).UiImport->semicolonToken = loc(5);
 623 } break;
 624 ./
 625
 626 UiImport: UiImportHead T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
 627 UiImport: UiImportHead T_AS JsIdentifier T_SEMICOLON ;
 628 /.
 629 case $rule_number: {
 630     sym(1).UiImport->asToken = loc(2);
 631     sym(1).UiImport->importIdToken = loc(3);
 632     sym(1).UiImport->importId = sym(3).sval;
 633     sym(1).UiImport->semicolonToken = loc(4);
 634 } break;
 635 ./
 636
 637
 638 UiImportHead: T_IMPORT ImportId ;
 639 /.
 640 case $rule_number: {
 641     AST::UiImport *node = 0;
 642
 643     if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
 644         node = makeAstNode<AST::UiImport>(driver->nodePool(), importIdLiteral->value);
 645         node->fileNameToken = loc(2);
 646     } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
 647         node = makeAstNode<AST::UiImport>(driver->nodePool(), qualifiedId);
 648         node->fileNameToken = loc(2);
 649     }
 650
 651     sym(1).Node = node;
 652
 653     if (node) {
 654         node->importToken = loc(1);
 655     } else {
 656        diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
 657          QLatin1String("Expected a qualified name id or a string literal")));
 658
 659         return false; // ### remove me
 660     }
 661 } break;
 662 ./
 663
 664 Empty: ;
 665 /.
 666 case $rule_number: {
 667     sym(1).Node = 0;
 668 } break;
 669 ./
 670
 671 UiRootMember: UiObjectDefinition ;
 672 /.
 673 case $rule_number: {
 674     sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
 675 } break;
 676 ./
 677
 678 UiObjectMemberList: UiObjectMember ;
 679 /.
 680 case $rule_number: {
 681     sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
 682 } break;
 683 ./
 684
 685 UiObjectMemberList: UiObjectMemberList UiObjectMember ;
 686 /.
 687 case $rule_number: {
 688     AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(),
 689         sym(1).UiObjectMemberList, sym(2).UiObjectMember);
 690     sym(1).Node = node;
 691 } break;
 692 ./
 693
 694 UiArrayMemberList: UiObjectDefinition ;
 695 /.
 696 case $rule_number: {
 697     sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember);
 698 } break;
 699 ./
 700
 701 UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ;
 702 /.
 703 case $rule_number: {
 704     AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(),
 705         sym(1).UiArrayMemberList, sym(3).UiObjectMember);
 706     node->commaToken = loc(2);
 707     sym(1).Node = node;
 708 } break;
 709 ./
 710
 711 UiObjectInitializer: T_LBRACE T_RBRACE ;
 712 /.
 713 case $rule_number: {
 714     AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0);
 715     node->lbraceToken = loc(1);
 716     node->rbraceToken = loc(2);
 717     sym(1).Node = node;
 718 }   break;
 719 ./
 720
 721 UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ;
 722 /.
 723 case $rule_number: {
 724     AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), sym(2).UiObjectMemberList->finish());
 725     node->lbraceToken = loc(1);
 726     node->rbraceToken = loc(3);
 727     sym(1).Node = node;
 728 }   break;
 729 ./
 730
 731 UiObjectDefinition: UiQualifiedId UiObjectInitializer ;
 732 /.
 733 case $rule_number: {
 734     AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId,
 735         sym(2).UiObjectInitializer);
 736     sym(1).Node = node;
 737 }   break;
 738 ./
 739
 740 UiObjectMember: UiObjectDefinition ;
 741
 742 UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
 743 /.
 744 case $rule_number: {
 745     AST::UiArrayBinding *node = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
 746         sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
 747     node->colonToken = loc(2);
 748     node->lbracketToken = loc(3);
 749     node->rbracketToken = loc(5);
 750     sym(1).Node = node;
 751 }   break;
 752 ./
 753
 754 UiObjectMember: UiQualifiedId             T_COLON UiQualifiedId  UiObjectInitializer ;
 755 /.
 756 case $rule_number: {
 757     AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
 758       sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
 759     node->colonToken = loc(2);
 760     sym(1).Node = node;
 761 } break;
 762 ./
 763
 764 UiObjectMember: UiQualifiedId             T_ON UiQualifiedId  UiObjectInitializer ;
 765 /.
 766 case $rule_number: {
 767     AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
 768       sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
 769     node->colonToken = loc(2);
 770     node->hasOnToken = true;
 771     sym(1).Node = node;
 772 } break;
 773 ./
 774
 775 UiObjectMember: UiQualifiedId T_COLON Block ;
 776 /.case $rule_number:./
 777
 778 UiObjectMember: UiQualifiedId T_COLON EmptyStatement ;
 779 /.case $rule_number:./
 780
 781 UiObjectMember: UiQualifiedId T_COLON ExpressionStatement ;
 782 /.case $rule_number:./
 783
 784 UiObjectMember: UiQualifiedId T_COLON IfStatement ; --- ### do we really want if statement in a binding?
 785 /.case $rule_number:./
 786
 787 /.
 788 {
 789     AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(),
 790         sym(1).UiQualifiedId, sym(3).Statement);
 791     node->colonToken = loc(2);
 792     sym(1).Node = node;
 793 }   break;
 794 ./
 795
 796 UiPropertyType: T_VAR ;
 797 /.
 798 case $rule_number:
 799 ./
 800 UiPropertyType: T_RESERVED_WORD ;
 801 /.
 802 case $rule_number: {
 803     sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
 804     break;
 805 }
 806 ./
 807
 808 UiPropertyType: T_IDENTIFIER ;
 809
 810 UiParameterListOpt: ;
 811 /.
 812 case $rule_number: {
 813   sym(1).Node = 0;
 814 } break;
 815 ./
 816
 817 UiParameterListOpt: UiParameterList ;
 818 /.
 819 case $rule_number: {
 820   sym(1).Node = sym(1).UiParameterList->finish ();
 821 } break;
 822 ./
 823
 824 UiParameterList: UiPropertyType JsIdentifier ;
 825 /.
 826 case $rule_number: {
 827   AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval);
 828   node->identifierToken = loc(2);
 829   sym(1).Node = node;
 830 } break;
 831 ./
 832
 833 UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ;
 834 /.
 835 case $rule_number: {
 836   AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).UiParameterList, sym(3).sval, sym(4).sval);
 837   node->commaToken = loc(2);
 838   node->identifierToken = loc(4);
 839   sym(1).Node = node;
 840 } break;
 841 ./
 842
 843 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_AUTOMATIC_SEMICOLON ;
 844 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ;
 845 /.
 846 case $rule_number: {
 847     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
 848     node->type = AST::UiPublicMember::Signal;
 849     node->propertyToken = loc(1);
 850     node->typeToken = loc(2);
 851     node->identifierToken = loc(2);
 852     node->parameters = sym(4).UiParameterList;
 853     node->semicolonToken = loc(6);
 854     sym(1).Node = node;
 855 }   break;
 856 ./
 857
 858 UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;
 859 UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ;
 860 /.
 861 case $rule_number: {
 862     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
 863     node->type = AST::UiPublicMember::Signal;
 864     node->propertyToken = loc(1);
 865     node->typeToken = loc(2);
 866     node->identifierToken = loc(2);
 867     node->semicolonToken = loc(3);
 868     sym(1).Node = node;
 869 }   break;
 870 ./
 871
 872 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_AUTOMATIC_SEMICOLON ;
 873 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ;
 874 /.
 875 case $rule_number: {
 876     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
 877     node->typeModifier = sym(2).sval;
 878     node->propertyToken = loc(1);
 879     node->typeModifierToken = loc(2);
 880     node->typeToken = loc(4);
 881     node->identifierToken = loc(6);
 882     node->semicolonToken = loc(7);
 883     sym(1).Node = node;
 884 }   break;
 885 ./
 886
 887 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
 888 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
 889 /.
 890 case $rule_number: {
 891     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
 892     node->propertyToken = loc(1);
 893     node->typeToken = loc(2);
 894     node->identifierToken = loc(3);
 895     node->semicolonToken = loc(4);
 896     sym(1).Node = node;
 897 }   break;
 898 ./
 899
 900 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
 901 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
 902 /.
 903 case $rule_number: {
 904     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval);
 905     node->isDefaultMember = true;
 906     node->defaultToken = loc(1);
 907     node->propertyToken = loc(2);
 908     node->typeToken = loc(3);
 909     node->identifierToken = loc(4);
 910     node->semicolonToken = loc(5);
 911     sym(1).Node = node;
 912 }   break;
 913 ./
 914
 915 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;
 916 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;
 917 /.
 918 case $rule_number: {
 919     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval,
 920         sym(5).Expression);
 921     node->propertyToken = loc(1);
 922     node->typeToken = loc(2);
 923     node->identifierToken = loc(3);
 924     node->colonToken = loc(4);
 925     node->semicolonToken = loc(6);
 926     sym(1).Node = node;
 927 }   break;
 928 ./
 929
 930 UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;
 931 UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;
 932 /.
 933 case $rule_number: {
 934     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
 935         sym(6).Expression);
 936     node->isReadonlyMember = true;
 937     node->readonlyToken = loc(1);
 938     node->propertyToken = loc(2);
 939     node->typeToken = loc(3);
 940     node->identifierToken = loc(4);
 941     node->colonToken = loc(5);
 942     node->semicolonToken = loc(7);
 943     sym(1).Node = node;
 944 }   break;
 945 ./
 946
 947 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;
 948 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;
 949 /.
 950 case $rule_number: {
 951     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
 952         sym(6).Expression);
 953     node->isDefaultMember = true;
 954     node->defaultToken = loc(1);
 955     node->propertyToken = loc(2);
 956     node->typeToken = loc(3);
 957     node->identifierToken = loc(4);
 958     node->colonToken = loc(5);
 959     node->semicolonToken = loc(7);
 960     sym(1).Node = node;
 961 }   break;
 962 ./
 963
 964 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
 965 /.
 966 case $rule_number: {
 967     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
 968     node->typeModifier = sym(2).sval;
 969     node->propertyToken = loc(1);
 970     node->typeModifierToken = loc(2);
 971     node->typeToken = loc(4);
 972     node->identifierToken = loc(6);
 973     node->semicolonToken = loc(7); // insert a fake ';' before ':'
 974
 975     AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(6).sval);
 976     propertyName->identifierToken = loc(6);
 977     propertyName->next = 0;
 978
 979     AST::UiArrayBinding *binding = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
 980         propertyName, sym(9).UiArrayMemberList->finish());
 981     binding->colonToken = loc(7);
 982     binding->lbracketToken = loc(8);
 983     binding->rbracketToken = loc(10);
 984
 985     node->binding = binding;
 986
 987     sym(1).Node = node;
 988 }   break;
 989 ./
 990
 991 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ;
 992 /.
 993 case $rule_number: {
 994     AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
 995     node->propertyToken = loc(1);
 996     node->typeToken = loc(2);
 997     node->identifierToken = loc(3);
 998     node->semicolonToken = loc(4); // insert a fake ';' before ':'
 999
1000     AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(3).sval);
1001     propertyName->identifierToken = loc(3);
1002     propertyName->next = 0;
1003
1004     AST::UiObjectBinding *binding = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
1005       propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
1006     binding->colonToken = loc(4);
1007
1008     node->binding = binding;
1009
1010     sym(1).Node = node;
1011 }   break;
1012 ./
1013
1014 UiObjectMember: FunctionDeclaration ;
1015 /.
1016 case $rule_number: {
1017     sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
1018 }   break;
1019 ./
1020
1021 UiObjectMember: VariableStatement ;
1022 /.
1023 case $rule_number: {
1024     sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
1025 }   break;
1026 ./
1027
1028 JsIdentifier: T_IDENTIFIER;
1029
1030 JsIdentifier: T_PROPERTY ;
1031 /.
1032 case $rule_number: {
1033     QString s = QLatin1String(QmlJSGrammar::spell[T_PROPERTY]);
1034     sym(1).sval = driver->intern(s.constData(), s.length());
1035     break;
1036 }
1037 ./
1038
1039 JsIdentifier: T_SIGNAL ;
1040 /.
1041 case $rule_number: {
1042     QString s = QLatin1String(QmlJSGrammar::spell[T_SIGNAL]);
1043     sym(1).sval = driver->intern(s.constData(), s.length());
1044     break;
1045 }
1046 ./
1047
1048 JsIdentifier: T_READONLY ;
1049 /.
1050 case $rule_number: {
1051     QString s = QLatin1String(QmlJSGrammar::spell[T_READONLY]);
1052     sym(1).sval = driver->intern(s.constData(), s.length());
1053     break;
1054 }
1055 ./
1056
1057 JsIdentifier: T_ON ;
1058 /.
1059 case $rule_number: {
1060     QString s = QLatin1String(QmlJSGrammar::spell[T_ON]);
1061     sym(1).sval = driver->intern(s.constData(), s.length());
1062     break;
1063 }
1064 ./
1065
1066 --------------------------------------------------------------------------------------------------------
1067 -- Expressions
1068 --------------------------------------------------------------------------------------------------------
1069
1070 PrimaryExpression: T_THIS ;
1071 /.
1072 case $rule_number: {
1073   AST::ThisExpression *node = makeAstNode<AST::ThisExpression> (driver->nodePool());
1074   node->thisToken = loc(1);
1075   sym(1).Node = node;
1076 } break;
1077 ./
1078
1079 PrimaryExpression: JsIdentifier ;
1080 /.
1081 case $rule_number: {
1082   AST::IdentifierExpression *node = makeAstNode<AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);
1083   node->identifierToken = loc(1);
1084   sym(1).Node = node;
1085 } break;
1086 ./
1087
1088 PrimaryExpression: T_NULL ;
1089 /.
1090 case $rule_number: {
1091   AST::NullExpression *node = makeAstNode<AST::NullExpression> (driver->nodePool());
1092   node->nullToken = loc(1);
1093   sym(1).Node = node;
1094 } break;
1095 ./
1096
1097 PrimaryExpression: T_TRUE ;
1098 /.
1099 case $rule_number: {
1100   AST::TrueLiteral *node = makeAstNode<AST::TrueLiteral> (driver->nodePool());
1101   node->trueToken = loc(1);
1102   sym(1).Node = node;
1103 } break;
1104 ./
1105
1106 PrimaryExpression: T_FALSE ;
1107 /.
1108 case $rule_number: {
1109   AST::FalseLiteral *node = makeAstNode<AST::FalseLiteral> (driver->nodePool());
1110   node->falseToken = loc(1);
1111   sym(1).Node = node;
1112 } break;
1113 ./
1114
1115 PrimaryExpression: T_NUMERIC_LITERAL ;
1116 /.
1117 case $rule_number: {
1118   AST::NumericLiteral *node = makeAstNode<AST::NumericLiteral> (driver->nodePool(), sym(1).dval);
1119   node->literalToken = loc(1);
1120   sym(1).Node = node;
1121 } break;
1122 ./
1123
1124 PrimaryExpression: T_MULTILINE_STRING_LITERAL ;
1125 /.case $rule_number:./
1126
1127 PrimaryExpression: T_STRING_LITERAL ;
1128 /.
1129 case $rule_number: {
1130   AST::StringLiteral *node = makeAstNode<AST::StringLiteral> (driver->nodePool(), sym(1).sval);
1131   node->literalToken = loc(1);
1132   sym(1).Node = node;
1133 } break;
1134 ./
1135
1136 PrimaryExpression: T_DIVIDE_ ;
1137 /:
1138 #define J_SCRIPT_REGEXPLITERAL_RULE1 $rule_number
1139 :/
1140 /.
1141 case $rule_number: {
1142   bool rx = lexer->scanRegExp(Lexer::NoPrefix);
1143   if (!rx) {
1144     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
1145     return false; // ### remove me
1146   }
1147
1148   loc(1).length = lexer->tokenLength();
1149
1150   AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
1151   node->literalToken = loc(1);
1152   sym(1).Node = node;
1153 } break;
1154 ./
1155
1156 PrimaryExpression: T_DIVIDE_EQ ;
1157 /:
1158 #define J_SCRIPT_REGEXPLITERAL_RULE2 $rule_number
1159 :/
1160 /.
1161 case $rule_number: {
1162   bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
1163   if (!rx) {
1164     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
1165     return false;
1166   }
1167
1168   loc(1).length = lexer->tokenLength();
1169
1170   AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
1171   node->literalToken = loc(1);
1172   sym(1).Node = node;
1173 } break;
1174 ./
1175
1176 PrimaryExpression: T_LBRACKET T_RBRACKET ;
1177 /.
1178 case $rule_number: {
1179   AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), (AST::Elision *) 0);
1180   node->lbracketToken = loc(1);
1181   node->rbracketToken = loc(2);
1182   sym(1).Node = node;
1183 } break;
1184 ./
1185
1186 PrimaryExpression: T_LBRACKET Elision T_RBRACKET ;
1187 /.
1188 case $rule_number: {
1189   AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision->finish());
1190   node->lbracketToken = loc(1);
1191   node->rbracketToken = loc(3);
1192   sym(1).Node = node;
1193 } break;
1194 ./
1195
1196 PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ;
1197 /.
1198 case $rule_number: {
1199   AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ());
1200   node->lbracketToken = loc(1);
1201   node->rbracketToken = loc(3);
1202   sym(1).Node = node;
1203 } break;
1204 ./
1205
1206 PrimaryExpression: T_LBRACKET ElementList T_COMMA T_RBRACKET ;
1207 /.
1208 case $rule_number: {
1209   AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
1210     (AST::Elision *) 0);
1211   node->lbracketToken = loc(1);
1212   node->commaToken = loc(3);
1213   node->rbracketToken = loc(4);
1214   sym(1).Node = node;
1215 } break;
1216 ./
1217
1218 PrimaryExpression: T_LBRACKET ElementList T_COMMA Elision T_RBRACKET ;
1219 /.
1220 case $rule_number: {
1221   AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
1222     sym(4).Elision->finish());
1223   node->lbracketToken = loc(1);
1224   node->commaToken = loc(3);
1225   node->rbracketToken = loc(5);
1226   sym(1).Node = node;
1227 } break;
1228 ./
1229
1230 -- PrimaryExpression: T_LBRACE T_RBRACE ;
1231 -- /.
1232 -- case $rule_number: {
1233 --   sym(1).Node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
1234 -- } break;
1235 -- ./
1236
1237 PrimaryExpression: T_LBRACE PropertyNameAndValueListOpt T_RBRACE ;
1238 /.
1239 case $rule_number: {
1240   AST::ObjectLiteral *node = 0;
1241   if (sym(2).Node)
1242     node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
1243         sym(2).PropertyNameAndValueList->finish ());
1244   else
1245     node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
1246   node->lbraceToken = loc(1);
1247   node->rbraceToken = loc(3);
1248   sym(1).Node = node;
1249 } break;
1250 ./
1251
1252 PrimaryExpression: T_LBRACE PropertyNameAndValueList T_COMMA T_RBRACE ;
1253 /.
1254 case $rule_number: {
1255   AST::ObjectLiteral *node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
1256     sym(2).PropertyNameAndValueList->finish ());
1257   node->lbraceToken = loc(1);
1258   node->rbraceToken = loc(4);
1259   sym(1).Node = node;
1260 } break;
1261 ./
1262
1263 PrimaryExpression: T_LPAREN Expression T_RPAREN ;
1264 /.
1265 case $rule_number: {
1266   AST::NestedExpression *node = makeAstNode<AST::NestedExpression>(driver->nodePool(), sym(2).Expression);
1267   node->lparenToken = loc(1);
1268   node->rparenToken = loc(3);
1269   sym(1).Node = node;
1270 } break;
1271 ./
1272
1273 UiQualifiedId: MemberExpression ;
1274 /.
1275 case $rule_number: {
1276   if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
1277     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken,
1278       QLatin1String("Ignored annotation")));
1279
1280     sym(1).Expression = mem->base;
1281   }
1282
1283   if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
1284     sym(1).UiQualifiedId = qualifiedId;
1285   } else {
1286     sym(1).UiQualifiedId = 0;
1287
1288     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
1289       QLatin1String("Expected a qualified name id")));
1290
1291     return false; // ### recover
1292   }
1293 } break;
1294 ./
1295
1296 ElementList: AssignmentExpression ;
1297 /.
1298 case $rule_number: {
1299   sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), (AST::Elision *) 0, sym(1).Expression);
1300 } break;
1301 ./
1302
1303 ElementList: Elision AssignmentExpression ;
1304 /.
1305 case $rule_number: {
1306   sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).Elision->finish(), sym(2).Expression);
1307 } break;
1308 ./
1309
1310 ElementList: ElementList T_COMMA AssignmentExpression ;
1311 /.
1312 case $rule_number: {
1313   AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList,
1314     (AST::Elision *) 0, sym(3).Expression);
1315   node->commaToken = loc(2);
1316   sym(1).Node = node;
1317 } break;
1318 ./
1319
1320 ElementList: ElementList T_COMMA Elision AssignmentExpression ;
1321 /.
1322 case $rule_number: {
1323   AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision->finish(),
1324     sym(4).Expression);
1325   node->commaToken = loc(2);
1326   sym(1).Node = node;
1327 } break;
1328 ./
1329
1330 Elision: T_COMMA ;
1331 /.
1332 case $rule_number: {
1333   AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool());
1334   node->commaToken = loc(1);
1335   sym(1).Node = node;
1336 } break;
1337 ./
1338
1339 Elision: Elision T_COMMA ;
1340 /.
1341 case $rule_number: {
1342   AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool(), sym(1).Elision);
1343   node->commaToken = loc(2);
1344   sym(1).Node = node;
1345 } break;
1346 ./
1347
1348 PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ;
1349 /.
1350 case $rule_number: {
1351   AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
1352       sym(1).PropertyName, sym(3).Expression);
1353   node->colonToken = loc(2);
1354   sym(1).Node = node;
1355 } break;
1356 ./
1357
1358 PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ;
1359 /.
1360 case $rule_number: {
1361   AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
1362       sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
1363   node->commaToken = loc(2);
1364   node->colonToken = loc(4);
1365   sym(1).Node = node;
1366 } break;
1367 ./
1368
1369 PropertyName: T_IDENTIFIER %prec SHIFT_THERE ;
1370 /.
1371 case $rule_number: {
1372   AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
1373   node->propertyNameToken = loc(1);
1374   sym(1).Node = node;
1375 } break;
1376 ./
1377
1378 PropertyName: T_SIGNAL ;
1379 /.case $rule_number:./
1380
1381 PropertyName: T_PROPERTY ;
1382 /.
1383 case $rule_number: {
1384   AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()));
1385   node->propertyNameToken = loc(1);
1386   sym(1).Node = node;
1387 } break;
1388 ./
1389
1390 PropertyName: T_STRING_LITERAL ;
1391 /.
1392 case $rule_number: {
1393   AST::StringLiteralPropertyName *node = makeAstNode<AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval);
1394   node->propertyNameToken = loc(1);
1395   sym(1).Node = node;
1396 } break;
1397 ./
1398
1399 PropertyName: T_NUMERIC_LITERAL ;
1400 /.
1401 case $rule_number: {
1402   AST::NumericLiteralPropertyName *node = makeAstNode<AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval);
1403   node->propertyNameToken = loc(1);
1404   sym(1).Node = node;
1405 } break;
1406 ./
1407
1408 PropertyName: ReservedIdentifier ;
1409 /.
1410 case $rule_number: {
1411   AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
1412   node->propertyNameToken = loc(1);
1413   sym(1).Node = node;
1414 } break;
1415 ./
1416
1417 ReservedIdentifier: T_BREAK ;
1418 /.
1419 case $rule_number:
1420 ./
1421 ReservedIdentifier: T_CASE ;
1422 /.
1423 case $rule_number:
1424 ./
1425 ReservedIdentifier: T_CATCH ;
1426 /.
1427 case $rule_number:
1428 ./
1429 ReservedIdentifier: T_CONTINUE ;
1430 /.
1431 case $rule_number:
1432 ./
1433 ReservedIdentifier: T_DEFAULT ;
1434 /.
1435 case $rule_number:
1436 ./
1437 ReservedIdentifier: T_DELETE ;
1438 /.
1439 case $rule_number:
1440 ./
1441 ReservedIdentifier: T_DO ;
1442 /.
1443 case $rule_number:
1444 ./
1445 ReservedIdentifier: T_ELSE ;
1446 /.
1447 case $rule_number:
1448 ./
1449 ReservedIdentifier: T_FALSE ;
1450 /.
1451 case $rule_number:
1452 ./
1453 ReservedIdentifier: T_FINALLY ;
1454 /.
1455 case $rule_number:
1456 ./
1457 ReservedIdentifier: T_FOR ;
1458 /.
1459 case $rule_number:
1460 ./
1461 ReservedIdentifier: T_FUNCTION ;
1462 /.
1463 case $rule_number:
1464 ./
1465 ReservedIdentifier: T_IF ;
1466 /.
1467 case $rule_number:
1468 ./
1469 ReservedIdentifier: T_IN ;
1470 /.
1471 case $rule_number:
1472 ./
1473 ReservedIdentifier: T_INSTANCEOF ;
1474 /.
1475 case $rule_number:
1476 ./
1477 ReservedIdentifier: T_NEW ;
1478 /.
1479 case $rule_number:
1480 ./
1481 ReservedIdentifier: T_NULL ;
1482 /.
1483 case $rule_number:
1484 ./
1485 ReservedIdentifier: T_RETURN ;
1486 /.
1487 case $rule_number:
1488 ./
1489 ReservedIdentifier: T_SWITCH ;
1490 /.
1491 case $rule_number:
1492 ./
1493 ReservedIdentifier: T_THIS ;
1494 /.
1495 case $rule_number:
1496 ./
1497 ReservedIdentifier: T_THROW ;
1498 /.
1499 case $rule_number:
1500 ./
1501 ReservedIdentifier: T_TRUE ;
1502 /.
1503 case $rule_number:
1504 ./
1505 ReservedIdentifier: T_TRY ;
1506 /.
1507 case $rule_number:
1508 ./
1509 ReservedIdentifier: T_TYPEOF ;
1510 /.
1511 case $rule_number:
1512 ./
1513 ReservedIdentifier: T_VAR ;
1514 /.
1515 case $rule_number:
1516 ./
1517 ReservedIdentifier: T_VOID ;
1518 /.
1519 case $rule_number:
1520 ./
1521 ReservedIdentifier: T_WHILE ;
1522 /.
1523 case $rule_number:
1524 ./
1525 ReservedIdentifier: T_CONST ;
1526 /.
1527 case $rule_number:
1528 ./
1529 ReservedIdentifier: T_DEBUGGER ;
1530 /.
1531 case $rule_number:
1532 ./
1533 ReservedIdentifier: T_RESERVED_WORD ;
1534 /.
1535 case $rule_number:
1536 ./
1537 ReservedIdentifier: T_WITH ;
1538 /.
1539 case $rule_number:
1540 {
1541   sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
1542 } break;
1543 ./
1544
1545 PropertyIdentifier: JsIdentifier ;
1546 PropertyIdentifier: ReservedIdentifier ;
1547
1548 MemberExpression: PrimaryExpression ;
1549 MemberExpression: FunctionExpression ;
1550
1551 MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ;
1552 /.
1553 case $rule_number: {
1554   AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
1555   node->lbracketToken = loc(2);
1556   node->rbracketToken = loc(4);
1557   sym(1).Node = node;
1558 } break;
1559 ./
1560
1561 MemberExpression: MemberExpression T_DOT PropertyIdentifier ;
1562 /.
1563 case $rule_number: {
1564   AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
1565   node->dotToken = loc(2);
1566   node->identifierToken = loc(3);
1567   sym(1).Node = node;
1568 } break;
1569 ./
1570
1571 MemberExpression: T_NEW MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
1572 /.
1573 case $rule_number: {
1574   AST::NewMemberExpression *node = makeAstNode<AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(4).ArgumentList);
1575   node->newToken = loc(1);
1576   node->lparenToken = loc(3);
1577   node->rparenToken = loc(5);
1578   sym(1).Node = node;
1579 } break;
1580 ./
1581
1582 NewExpression: MemberExpression ;
1583
1584 NewExpression: T_NEW NewExpression ;
1585 /.
1586 case $rule_number: {
1587   AST::NewExpression *node = makeAstNode<AST::NewExpression> (driver->nodePool(), sym(2).Expression);
1588   node->newToken = loc(1);
1589   sym(1).Node = node;
1590 } break;
1591 ./
1592
1593 CallExpression: MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
1594 /.
1595 case $rule_number: {
1596   AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
1597   node->lparenToken = loc(2);
1598   node->rparenToken = loc(4);
1599   sym(1).Node = node;
1600 } break;
1601 ./
1602
1603 CallExpression: CallExpression T_LPAREN ArgumentListOpt T_RPAREN ;
1604 /.
1605 case $rule_number: {
1606   AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
1607   node->lparenToken = loc(2);
1608   node->rparenToken = loc(4);
1609   sym(1).Node = node;
1610 } break;
1611 ./
1612
1613 CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ;
1614 /.
1615 case $rule_number: {
1616   AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
1617   node->lbracketToken = loc(2);
1618   node->rbracketToken = loc(4);
1619   sym(1).Node = node;
1620 } break;
1621 ./
1622
1623 CallExpression: CallExpression T_DOT PropertyIdentifier ;
1624 /.
1625 case $rule_number: {
1626   AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
1627   node->dotToken = loc(2);
1628   node->identifierToken = loc(3);
1629   sym(1).Node = node;
1630 } break;
1631 ./
1632
1633 ArgumentListOpt: ;
1634 /.
1635 case $rule_number: {
1636   sym(1).Node = 0;
1637 } break;
1638 ./
1639
1640 ArgumentListOpt: ArgumentList ;
1641 /.
1642 case $rule_number: {
1643   sym(1).Node = sym(1).ArgumentList->finish();
1644 } break;
1645 ./
1646
1647 ArgumentList: AssignmentExpression ;
1648 /.
1649 case $rule_number: {
1650   sym(1).Node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).Expression);
1651 } break;
1652 ./
1653
1654 ArgumentList: ArgumentList T_COMMA AssignmentExpression ;
1655 /.
1656 case $rule_number: {
1657   AST::ArgumentList *node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression);
1658   node->commaToken = loc(2);
1659   sym(1).Node = node;
1660 } break;
1661 ./
1662
1663 LeftHandSideExpression: NewExpression ;
1664 LeftHandSideExpression: CallExpression ;
1665 PostfixExpression: LeftHandSideExpression ;
1666
1667 PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ;
1668 /.
1669 case $rule_number: {
1670   AST::PostIncrementExpression *node = makeAstNode<AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression);
1671   node->incrementToken = loc(2);
1672   sym(1).Node = node;
1673 } break;
1674 ./
1675
1676 PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ;
1677 /.
1678 case $rule_number: {
1679   AST::PostDecrementExpression *node = makeAstNode<AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression);
1680   node->decrementToken = loc(2);
1681   sym(1).Node = node;
1682 } break;
1683 ./
1684
1685 UnaryExpression: PostfixExpression ;
1686
1687 UnaryExpression: T_DELETE UnaryExpression ;
1688 /.
1689 case $rule_number: {
1690   AST::DeleteExpression *node = makeAstNode<AST::DeleteExpression> (driver->nodePool(), sym(2).Expression);
1691   node->deleteToken = loc(1);
1692   sym(1).Node = node;
1693 } break;
1694 ./
1695
1696 UnaryExpression: T_VOID UnaryExpression ;
1697 /.
1698 case $rule_number: {
1699   AST::VoidExpression *node = makeAstNode<AST::VoidExpression> (driver->nodePool(), sym(2).Expression);
1700   node->voidToken = loc(1);
1701   sym(1).Node = node;
1702 } break;
1703 ./
1704
1705 UnaryExpression: T_TYPEOF UnaryExpression ;
1706 /.
1707 case $rule_number: {
1708   AST::TypeOfExpression *node = makeAstNode<AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression);
1709   node->typeofToken = loc(1);
1710   sym(1).Node = node;
1711 } break;
1712 ./
1713
1714 UnaryExpression: T_PLUS_PLUS UnaryExpression ;
1715 /.
1716 case $rule_number: {
1717   AST::PreIncrementExpression *node = makeAstNode<AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression);
1718   node->incrementToken = loc(1);
1719   sym(1).Node = node;
1720 } break;
1721 ./
1722
1723 UnaryExpression: T_MINUS_MINUS UnaryExpression ;
1724 /.
1725 case $rule_number: {
1726   AST::PreDecrementExpression *node = makeAstNode<AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression);
1727   node->decrementToken = loc(1);
1728   sym(1).Node = node;
1729 } break;
1730 ./
1731
1732 UnaryExpression: T_PLUS UnaryExpression ;
1733 /.
1734 case $rule_number: {
1735   AST::UnaryPlusExpression *node = makeAstNode<AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression);
1736   node->plusToken = loc(1);
1737   sym(1).Node = node;
1738 } break;
1739 ./
1740
1741 UnaryExpression: T_MINUS UnaryExpression ;
1742 /.
1743 case $rule_number: {
1744   AST::UnaryMinusExpression *node = makeAstNode<AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression);
1745   node->minusToken = loc(1);
1746   sym(1).Node = node;
1747 } break;
1748 ./
1749
1750 UnaryExpression: T_TILDE UnaryExpression ;
1751 /.
1752 case $rule_number: {
1753   AST::TildeExpression *node = makeAstNode<AST::TildeExpression> (driver->nodePool(), sym(2).Expression);
1754   node->tildeToken = loc(1);
1755   sym(1).Node = node;
1756 } break;
1757 ./
1758
1759 UnaryExpression: T_NOT UnaryExpression ;
1760 /.
1761 case $rule_number: {
1762   AST::NotExpression *node = makeAstNode<AST::NotExpression> (driver->nodePool(), sym(2).Expression);
1763   node->notToken = loc(1);
1764   sym(1).Node = node;
1765 } break;
1766 ./
1767
1768 MultiplicativeExpression: UnaryExpression ;
1769
1770 MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ;
1771 /.
1772 case $rule_number: {
1773   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1774     QSOperator::Mul, sym(3).Expression);
1775   node->operatorToken = loc(2);
1776   sym(1).Node = node;
1777 } break;
1778 ./
1779
1780 MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ;
1781 /.
1782 case $rule_number: {
1783   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1784     QSOperator::Div, sym(3).Expression);
1785   node->operatorToken = loc(2);
1786   sym(1).Node = node;
1787 } break;
1788 ./
1789
1790 MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ;
1791 /.
1792 case $rule_number: {
1793   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1794     QSOperator::Mod, sym(3).Expression);
1795   node->operatorToken = loc(2);
1796   sym(1).Node = node;
1797 } break;
1798 ./
1799
1800 AdditiveExpression: MultiplicativeExpression ;
1801
1802 AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ;
1803 /.
1804 case $rule_number: {
1805   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1806     QSOperator::Add, sym(3).Expression);
1807   node->operatorToken = loc(2);
1808   sym(1).Node = node;
1809 } break;
1810 ./
1811
1812 AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ;
1813 /.
1814 case $rule_number: {
1815   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1816     QSOperator::Sub, sym(3).Expression);
1817   node->operatorToken = loc(2);
1818   sym(1).Node = node;
1819 } break;
1820 ./
1821
1822 ShiftExpression: AdditiveExpression ;
1823
1824 ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ;
1825 /.
1826 case $rule_number: {
1827   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1828     QSOperator::LShift, sym(3).Expression);
1829   node->operatorToken = loc(2);
1830   sym(1).Node = node;
1831 } break;
1832 ./
1833
1834 ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ;
1835 /.
1836 case $rule_number: {
1837   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1838     QSOperator::RShift, sym(3).Expression);
1839   node->operatorToken = loc(2);
1840   sym(1).Node = node;
1841 } break;
1842 ./
1843
1844 ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ;
1845 /.
1846 case $rule_number: {
1847   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1848     QSOperator::URShift, sym(3).Expression);
1849   node->operatorToken = loc(2);
1850   sym(1).Node = node;
1851 } break;
1852 ./
1853
1854 RelationalExpression: ShiftExpression ;
1855
1856 RelationalExpression: RelationalExpression T_LT ShiftExpression ;
1857 /.
1858 case $rule_number: {
1859   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1860     QSOperator::Lt, sym(3).Expression);
1861   node->operatorToken = loc(2);
1862   sym(1).Node = node;
1863 } break;
1864 ./
1865
1866 RelationalExpression: RelationalExpression T_GT ShiftExpression ;
1867 /.
1868 case $rule_number: {
1869   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1870     QSOperator::Gt, sym(3).Expression);
1871   node->operatorToken = loc(2);
1872   sym(1).Node = node;
1873 } break;
1874 ./
1875
1876 RelationalExpression: RelationalExpression T_LE ShiftExpression ;
1877 /.
1878 case $rule_number: {
1879   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1880     QSOperator::Le, sym(3).Expression);
1881   node->operatorToken = loc(2);
1882   sym(1).Node = node;
1883 } break;
1884 ./
1885
1886 RelationalExpression: RelationalExpression T_GE ShiftExpression ;
1887 /.
1888 case $rule_number: {
1889   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1890     QSOperator::Ge, sym(3).Expression);
1891   node->operatorToken = loc(2);
1892   sym(1).Node = node;
1893 } break;
1894 ./
1895
1896 RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ;
1897 /.
1898 case $rule_number: {
1899   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1900     QSOperator::InstanceOf, sym(3).Expression);
1901   node->operatorToken = loc(2);
1902   sym(1).Node = node;
1903 } break;
1904 ./
1905
1906 RelationalExpression: RelationalExpression T_IN ShiftExpression ;
1907 /.
1908 case $rule_number: {
1909   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1910     QSOperator::In, sym(3).Expression);
1911   node->operatorToken = loc(2);
1912   sym(1).Node = node;
1913 } break;
1914 ./
1915
1916 RelationalExpressionNotIn: ShiftExpression ;
1917
1918 RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ;
1919 /.
1920 case $rule_number: {
1921   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1922     QSOperator::Lt, sym(3).Expression);
1923   node->operatorToken = loc(2);
1924   sym(1).Node = node;
1925 } break;
1926 ./
1927
1928 RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ;
1929 /.
1930 case $rule_number: {
1931   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1932     QSOperator::Gt, sym(3).Expression);
1933   node->operatorToken = loc(2);
1934   sym(1).Node = node;
1935 } break;
1936 ./
1937
1938 RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ;
1939 /.
1940 case $rule_number: {
1941   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1942     QSOperator::Le, sym(3).Expression);
1943   node->operatorToken = loc(2);
1944   sym(1).Node = node;
1945 } break;
1946 ./
1947
1948 RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ;
1949 /.
1950 case $rule_number: {
1951   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1952    QSOperator::Ge, sym(3).Expression);
1953   node->operatorToken = loc(2);
1954   sym(1).Node = node;
1955 } break;
1956 ./
1957
1958 RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ;
1959 /.
1960 case $rule_number: {
1961   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1962     QSOperator::InstanceOf, sym(3).Expression);
1963   node->operatorToken = loc(2);
1964   sym(1).Node = node;
1965 } break;
1966 ./
1967
1968 EqualityExpression: RelationalExpression ;
1969
1970 EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ;
1971 /.
1972 case $rule_number: {
1973   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1974     QSOperator::Equal, sym(3).Expression);
1975   node->operatorToken = loc(2);
1976   sym(1).Node = node;
1977 } break;
1978 ./
1979
1980 EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ;
1981 /.
1982 case $rule_number: {
1983   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1984     QSOperator::NotEqual, sym(3).Expression);
1985   node->operatorToken = loc(2);
1986   sym(1).Node = node;
1987 } break;
1988 ./
1989
1990 EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ;
1991 /.
1992 case $rule_number: {
1993   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
1994     QSOperator::StrictEqual, sym(3).Expression);
1995   node->operatorToken = loc(2);
1996   sym(1).Node = node;
1997 } break;
1998 ./
1999
2000 EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ;
2001 /.
2002 case $rule_number: {
2003   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2004     QSOperator::StrictNotEqual, sym(3).Expression);
2005   node->operatorToken = loc(2);
2006   sym(1).Node = node;
2007 } break;
2008 ./
2009
2010 EqualityExpressionNotIn: RelationalExpressionNotIn ;
2011
2012 EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ;
2013 /.
2014 case $rule_number: {
2015   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2016     QSOperator::Equal, sym(3).Expression);
2017   node->operatorToken = loc(2);
2018   sym(1).Node = node;
2019 } break;
2020 ./
2021
2022 EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn;
2023 /.
2024 case $rule_number: {
2025   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2026     QSOperator::NotEqual, sym(3).Expression);
2027   node->operatorToken = loc(2);
2028   sym(1).Node = node;
2029 } break;
2030 ./
2031
2032 EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ;
2033 /.
2034 case $rule_number: {
2035   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2036     QSOperator::StrictEqual, sym(3).Expression);
2037   node->operatorToken = loc(2);
2038   sym(1).Node = node;
2039 } break;
2040 ./
2041
2042 EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ;
2043 /.
2044 case $rule_number: {
2045   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2046     QSOperator::StrictNotEqual, sym(3).Expression);
2047   node->operatorToken = loc(2);
2048   sym(1).Node = node;
2049 } break;
2050 ./
2051
2052 BitwiseANDExpression: EqualityExpression ;
2053
2054 BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ;
2055 /.
2056 case $rule_number: {
2057   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2058     QSOperator::BitAnd, sym(3).Expression);
2059   node->operatorToken = loc(2);
2060   sym(1).Node = node;
2061 } break;
2062 ./
2063
2064 BitwiseANDExpressionNotIn: EqualityExpressionNotIn ;
2065
2066 BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ;
2067 /.
2068 case $rule_number: {
2069   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2070     QSOperator::BitAnd, sym(3).Expression);
2071   node->operatorToken = loc(2);
2072   sym(1).Node = node;
2073 } break;
2074 ./
2075
2076 BitwiseXORExpression: BitwiseANDExpression ;
2077
2078 BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ;
2079 /.
2080 case $rule_number: {
2081   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2082     QSOperator::BitXor, sym(3).Expression);
2083   node->operatorToken = loc(2);
2084   sym(1).Node = node;
2085 } break;
2086 ./
2087
2088 BitwiseXORExpressionNotIn: BitwiseANDExpressionNotIn ;
2089
2090 BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ;
2091 /.
2092 case $rule_number: {
2093   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2094     QSOperator::BitXor, sym(3).Expression);
2095   node->operatorToken = loc(2);
2096   sym(1).Node = node;
2097 } break;
2098 ./
2099
2100 BitwiseORExpression: BitwiseXORExpression ;
2101
2102 BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ;
2103 /.
2104 case $rule_number: {
2105   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2106     QSOperator::BitOr, sym(3).Expression);
2107   node->operatorToken = loc(2);
2108   sym(1).Node = node;
2109 } break;
2110 ./
2111
2112 BitwiseORExpressionNotIn: BitwiseXORExpressionNotIn ;
2113
2114 BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ;
2115 /.
2116 case $rule_number: {
2117   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2118     QSOperator::BitOr, sym(3).Expression);
2119   node->operatorToken = loc(2);
2120   sym(1).Node = node;
2121 } break;
2122 ./
2123
2124 LogicalANDExpression: BitwiseORExpression ;
2125
2126 LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ;
2127 /.
2128 case $rule_number: {
2129   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2130     QSOperator::And, sym(3).Expression);
2131   node->operatorToken = loc(2);
2132   sym(1).Node = node;
2133 } break;
2134 ./
2135
2136 LogicalANDExpressionNotIn: BitwiseORExpressionNotIn ;
2137
2138 LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ;
2139 /.
2140 case $rule_number: {
2141   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2142     QSOperator::And, sym(3).Expression);
2143   node->operatorToken = loc(2);
2144   sym(1).Node = node;
2145 } break;
2146 ./
2147
2148 LogicalORExpression: LogicalANDExpression ;
2149
2150 LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ;
2151 /.
2152 case $rule_number: {
2153   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2154     QSOperator::Or, sym(3).Expression);
2155   node->operatorToken = loc(2);
2156   sym(1).Node = node;
2157 } break;
2158 ./
2159
2160 LogicalORExpressionNotIn: LogicalANDExpressionNotIn ;
2161
2162 LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ;
2163 /.
2164 case $rule_number: {
2165   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2166     QSOperator::Or, sym(3).Expression);
2167   node->operatorToken = loc(2);
2168   sym(1).Node = node;
2169 } break;
2170 ./
2171
2172 ConditionalExpression: LogicalORExpression ;
2173
2174 ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ;
2175 /.
2176 case $rule_number: {
2177   AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
2178     sym(3).Expression, sym(5).Expression);
2179   node->questionToken = loc(2);
2180   node->colonToken = loc(4);
2181   sym(1).Node = node;
2182 } break;
2183 ./
2184
2185 ConditionalExpressionNotIn: LogicalORExpressionNotIn ;
2186
2187 ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ;
2188 /.
2189 case $rule_number: {
2190   AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
2191     sym(3).Expression, sym(5).Expression);
2192   node->questionToken = loc(2);
2193   node->colonToken = loc(4);
2194   sym(1).Node = node;
2195 } break;
2196 ./
2197
2198 AssignmentExpression: ConditionalExpression ;
2199
2200 AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ;
2201 /.
2202 case $rule_number: {
2203   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2204     sym(2).ival, sym(3).Expression);
2205   node->operatorToken = loc(2);
2206   sym(1).Node = node;
2207 } break;
2208 ./
2209
2210 AssignmentExpressionNotIn: ConditionalExpressionNotIn ;
2211
2212 AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ;
2213 /.
2214 case $rule_number: {
2215   AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
2216     sym(2).ival, sym(3).Expression);
2217   node->operatorToken = loc(2);
2218   sym(1).Node = node;
2219 } break;
2220 ./
2221
2222 AssignmentOperator: T_EQ ;
2223 /.
2224 case $rule_number: {
2225   sym(1).ival = QSOperator::Assign;
2226 } break;
2227 ./
2228
2229 AssignmentOperator: T_STAR_EQ ;
2230 /.
2231 case $rule_number: {
2232   sym(1).ival = QSOperator::InplaceMul;
2233 } break;
2234 ./
2235
2236 AssignmentOperator: T_DIVIDE_EQ ;
2237 /.
2238 case $rule_number: {
2239   sym(1).ival = QSOperator::InplaceDiv;
2240 } break;
2241 ./
2242
2243 AssignmentOperator: T_REMAINDER_EQ ;
2244 /.
2245 case $rule_number: {
2246   sym(1).ival = QSOperator::InplaceMod;
2247 } break;
2248 ./
2249
2250 AssignmentOperator: T_PLUS_EQ ;
2251 /.
2252 case $rule_number: {
2253   sym(1).ival = QSOperator::InplaceAdd;
2254 } break;
2255 ./
2256
2257 AssignmentOperator: T_MINUS_EQ ;
2258 /.
2259 case $rule_number: {
2260   sym(1).ival = QSOperator::InplaceSub;
2261 } break;
2262 ./
2263
2264 AssignmentOperator: T_LT_LT_EQ ;
2265 /.
2266 case $rule_number: {
2267   sym(1).ival = QSOperator::InplaceLeftShift;
2268 } break;
2269 ./
2270
2271 AssignmentOperator: T_GT_GT_EQ ;
2272 /.
2273 case $rule_number: {
2274   sym(1).ival = QSOperator::InplaceRightShift;
2275 } break;
2276 ./
2277
2278 AssignmentOperator: T_GT_GT_GT_EQ ;
2279 /.
2280 case $rule_number: {
2281   sym(1).ival = QSOperator::InplaceURightShift;
2282 } break;
2283 ./
2284
2285 AssignmentOperator: T_AND_EQ ;
2286 /.
2287 case $rule_number: {
2288   sym(1).ival = QSOperator::InplaceAnd;
2289 } break;
2290 ./
2291
2292 AssignmentOperator: T_XOR_EQ ;
2293 /.
2294 case $rule_number: {
2295   sym(1).ival = QSOperator::InplaceXor;
2296 } break;
2297 ./
2298
2299 AssignmentOperator: T_OR_EQ ;
2300 /.
2301 case $rule_number: {
2302   sym(1).ival = QSOperator::InplaceOr;
2303 } break;
2304 ./
2305
2306 Expression: AssignmentExpression ;
2307
2308 Expression: Expression T_COMMA AssignmentExpression ;
2309 /.
2310 case $rule_number: {
2311   AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
2312   node->commaToken = loc(2);
2313   sym(1).Node = node;
2314 } break;
2315 ./
2316
2317 ExpressionOpt: ;
2318 /.
2319 case $rule_number: {
2320   sym(1).Node = 0;
2321 } break;
2322 ./
2323
2324 ExpressionOpt: Expression ;
2325
2326 ExpressionNotIn: AssignmentExpressionNotIn ;
2327
2328 ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ;
2329 /.
2330 case $rule_number: {
2331   AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
2332   node->commaToken = loc(2);
2333   sym(1).Node = node;
2334 } break;
2335 ./
2336
2337 ExpressionNotInOpt: ;
2338 /.
2339 case $rule_number: {
2340   sym(1).Node = 0;
2341 } break;
2342 ./
2343
2344 ExpressionNotInOpt: ExpressionNotIn ;
2345
2346 Statement: Block ;
2347 Statement: VariableStatement ;
2348 Statement: EmptyStatement ;
2349 Statement: ExpressionStatement ;
2350 Statement: IfStatement ;
2351 Statement: IterationStatement ;
2352 Statement: ContinueStatement ;
2353 Statement: BreakStatement ;
2354 Statement: ReturnStatement ;
2355 Statement: WithStatement ;
2356 Statement: LabelledStatement ;
2357 Statement: SwitchStatement ;
2358 Statement: ThrowStatement ;
2359 Statement: TryStatement ;
2360 Statement: DebuggerStatement ;
2361
2362
2363 Block: T_LBRACE StatementListOpt T_RBRACE ;
2364 /.
2365 case $rule_number: {
2366   AST::Block *node = makeAstNode<AST::Block> (driver->nodePool(), sym(2).StatementList);
2367   node->lbraceToken = loc(1);
2368   node->rbraceToken = loc(3);
2369   sym(1).Node = node;
2370 } break;
2371 ./
2372
2373 StatementList: Statement ;
2374 /.
2375 case $rule_number: {
2376   sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).Statement);
2377 } break;
2378 ./
2379
2380 StatementList: StatementList Statement ;
2381 /.
2382 case $rule_number: {
2383   sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement);
2384 } break;
2385 ./
2386
2387 StatementListOpt: ;
2388 /.
2389 case $rule_number: {
2390   sym(1).Node = 0;
2391 } break;
2392 ./
2393
2394 StatementListOpt: StatementList ;
2395 /.
2396 case $rule_number: {
2397   sym(1).Node = sym(1).StatementList->finish ();
2398 } break;
2399 ./
2400
2401 VariableStatement: VariableDeclarationKind VariableDeclarationList T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2402 VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ;
2403 /.
2404 case $rule_number: {
2405   AST::VariableStatement *node = makeAstNode<AST::VariableStatement> (driver->nodePool(),
2406      sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
2407   node->declarationKindToken = loc(1);
2408   node->semicolonToken = loc(3);
2409   sym(1).Node = node;
2410 } break;
2411 ./
2412
2413 VariableDeclarationKind: T_CONST ;
2414 /.
2415 case $rule_number: {
2416   sym(1).ival = T_CONST;
2417 } break;
2418 ./
2419
2420 VariableDeclarationKind: T_VAR ;
2421 /.
2422 case $rule_number: {
2423   sym(1).ival = T_VAR;
2424 } break;
2425 ./
2426
2427 VariableDeclarationList: VariableDeclaration ;
2428 /.
2429 case $rule_number: {
2430   sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
2431 } break;
2432 ./
2433
2434 VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ;
2435 /.
2436 case $rule_number: {
2437   AST::VariableDeclarationList *node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(),
2438     sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
2439   node->commaToken = loc(2);
2440   sym(1).Node = node;
2441 } break;
2442 ./
2443
2444 VariableDeclarationListNotIn: VariableDeclarationNotIn ;
2445 /.
2446 case $rule_number: {
2447   sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
2448 } break;
2449 ./
2450
2451 VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ;
2452 /.
2453 case $rule_number: {
2454   sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
2455 } break;
2456 ./
2457
2458 VariableDeclaration: JsIdentifier InitialiserOpt ;
2459 /.
2460 case $rule_number: {
2461   AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
2462   node->identifierToken = loc(1);
2463   sym(1).Node = node;
2464 } break;
2465 ./
2466
2467 VariableDeclarationNotIn: JsIdentifier InitialiserNotInOpt ;
2468 /.
2469 case $rule_number: {
2470   AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
2471   node->identifierToken = loc(1);
2472   sym(1).Node = node;
2473 } break;
2474 ./
2475
2476 Initialiser: T_EQ AssignmentExpression ;
2477 /.
2478 case $rule_number: {
2479   // ### TODO: AST for initializer
2480   sym(1) = sym(2);
2481 } break;
2482 ./
2483
2484 InitialiserOpt: ;
2485 /.
2486 case $rule_number: {
2487   sym(1).Node = 0;
2488 } break;
2489 ./
2490
2491 InitialiserOpt: Initialiser ;
2492
2493 InitialiserNotIn: T_EQ AssignmentExpressionNotIn ;
2494 /.
2495 case $rule_number: {
2496   // ### TODO: AST for initializer
2497   sym(1) = sym(2);
2498 } break;
2499 ./
2500
2501 InitialiserNotInOpt: ;
2502 /.
2503 case $rule_number: {
2504   sym(1).Node = 0;
2505 } break;
2506 ./
2507
2508 InitialiserNotInOpt: InitialiserNotIn ;
2509
2510 EmptyStatement: T_SEMICOLON ;
2511 /.
2512 case $rule_number: {
2513   AST::EmptyStatement *node = makeAstNode<AST::EmptyStatement> (driver->nodePool());
2514   node->semicolonToken = loc(1);
2515   sym(1).Node = node;
2516 } break;
2517 ./
2518
2519 ExpressionStatement: Expression T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2520 ExpressionStatement: Expression T_SEMICOLON ;
2521 /.
2522 case $rule_number: {
2523   AST::ExpressionStatement *node = makeAstNode<AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression);
2524   node->semicolonToken = loc(2);
2525   sym(1).Node = node;
2526 } break;
2527 ./
2528
2529 IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ;
2530 /.
2531 case $rule_number: {
2532   AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement);
2533   node->ifToken = loc(1);
2534   node->lparenToken = loc(2);
2535   node->rparenToken = loc(4);
2536   node->elseToken = loc(5);
2537   sym(1).Node = node;
2538 } break;
2539 ./
2540
2541 IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ;
2542 /.
2543 case $rule_number: {
2544   AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
2545   node->ifToken = loc(1);
2546   node->lparenToken = loc(2);
2547   node->rparenToken = loc(4);
2548   sym(1).Node = node;
2549 } break;
2550 ./
2551
2552
2553 IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2554 IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ;
2555 /.
2556 case $rule_number: {
2557   AST::DoWhileStatement *node = makeAstNode<AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression);
2558   node->doToken = loc(1);
2559   node->whileToken = loc(3);
2560   node->lparenToken = loc(4);
2561   node->rparenToken = loc(6);
2562   node->semicolonToken = loc(7);
2563   sym(1).Node = node;
2564 } break;
2565 ./
2566
2567 IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ;
2568 /.
2569 case $rule_number: {
2570   AST::WhileStatement *node = makeAstNode<AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
2571   node->whileToken = loc(1);
2572   node->lparenToken = loc(2);
2573   node->rparenToken = loc(4);
2574   sym(1).Node = node;
2575 } break;
2576 ./
2577
2578 IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
2579 /.
2580 case $rule_number: {
2581   AST::ForStatement *node = makeAstNode<AST::ForStatement> (driver->nodePool(), sym(3).Expression,
2582     sym(5).Expression, sym(7).Expression, sym(9).Statement);
2583   node->forToken = loc(1);
2584   node->lparenToken = loc(2);
2585   node->firstSemicolonToken = loc(4);
2586   node->secondSemicolonToken = loc(6);
2587   node->rparenToken = loc(8);
2588   sym(1).Node = node;
2589 } break;
2590 ./
2591
2592 IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
2593 /.
2594 case $rule_number: {
2595   AST::LocalForStatement *node = makeAstNode<AST::LocalForStatement> (driver->nodePool(),
2596      sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
2597      sym(8).Expression, sym(10).Statement);
2598   node->forToken = loc(1);
2599   node->lparenToken = loc(2);
2600   node->varToken = loc(3);
2601   node->firstSemicolonToken = loc(5);
2602   node->secondSemicolonToken = loc(7);
2603   node->rparenToken = loc(9);
2604   sym(1).Node = node;
2605 } break;
2606 ./
2607
2608 IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ;
2609 /.
2610 case $rule_number: {
2611   AST:: ForEachStatement *node = makeAstNode<AST::ForEachStatement> (driver->nodePool(), sym(3).Expression,
2612     sym(5).Expression, sym(7).Statement);
2613   node->forToken = loc(1);
2614   node->lparenToken = loc(2);
2615   node->inToken = loc(4);
2616   node->rparenToken = loc(6);
2617   sym(1).Node = node;
2618 } break;
2619 ./
2620
2621 IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ;
2622 /.
2623 case $rule_number: {
2624   AST::LocalForEachStatement *node = makeAstNode<AST::LocalForEachStatement> (driver->nodePool(),
2625     sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
2626   node->forToken = loc(1);
2627   node->lparenToken = loc(2);
2628   node->varToken = loc(3);
2629   node->inToken = loc(5);
2630   node->rparenToken = loc(7);
2631   sym(1).Node = node;
2632 } break;
2633 ./
2634
2635 ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2636 ContinueStatement: T_CONTINUE T_SEMICOLON ;
2637 /.
2638 case $rule_number: {
2639   AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool());
2640   node->continueToken = loc(1);
2641   node->semicolonToken = loc(2);
2642   sym(1).Node = node;
2643 } break;
2644 ./
2645
2646 ContinueStatement: T_CONTINUE JsIdentifier T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2647 ContinueStatement: T_CONTINUE JsIdentifier T_SEMICOLON ;
2648 /.
2649 case $rule_number: {
2650   AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool(), sym(2).sval);
2651   node->continueToken = loc(1);
2652   node->identifierToken = loc(2);
2653   node->semicolonToken = loc(3);
2654   sym(1).Node = node;
2655 } break;
2656 ./
2657
2658 BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2659 BreakStatement: T_BREAK T_SEMICOLON ;
2660 /.
2661 case $rule_number: {
2662   AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool());
2663   node->breakToken = loc(1);
2664   node->semicolonToken = loc(2);
2665   sym(1).Node = node;
2666 } break;
2667 ./
2668
2669 BreakStatement: T_BREAK JsIdentifier T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2670 BreakStatement: T_BREAK JsIdentifier T_SEMICOLON ;
2671 /.
2672 case $rule_number: {
2673   AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool(), sym(2).sval);
2674   node->breakToken = loc(1);
2675   node->identifierToken = loc(2);
2676   node->semicolonToken = loc(3);
2677   sym(1).Node = node;
2678 } break;
2679 ./
2680
2681 ReturnStatement: T_RETURN ExpressionOpt T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2682 ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ;
2683 /.
2684 case $rule_number: {
2685   AST::ReturnStatement *node = makeAstNode<AST::ReturnStatement> (driver->nodePool(), sym(2).Expression);
2686   node->returnToken = loc(1);
2687   node->semicolonToken = loc(3);
2688   sym(1).Node = node;
2689 } break;
2690 ./
2691
2692 WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ;
2693 /.
2694 case $rule_number: {
2695   AST::WithStatement *node = makeAstNode<AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
2696   node->withToken = loc(1);
2697   node->lparenToken = loc(2);
2698   node->rparenToken = loc(4);
2699   sym(1).Node = node;
2700 } break;
2701 ./
2702
2703 SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ;
2704 /.
2705 case $rule_number: {
2706   AST::SwitchStatement *node = makeAstNode<AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock);
2707   node->switchToken = loc(1);
2708   node->lparenToken = loc(2);
2709   node->rparenToken = loc(4);
2710   sym(1).Node = node;
2711 } break;
2712 ./
2713
2714 CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ;
2715 /.
2716 case $rule_number: {
2717   AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses);
2718   node->lbraceToken = loc(1);
2719   node->rbraceToken = loc(3);
2720   sym(1).Node = node;
2721 } break;
2722 ./
2723
2724 CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ;
2725 /.
2726 case $rule_number: {
2727   AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
2728   node->lbraceToken = loc(1);
2729   node->rbraceToken = loc(5);
2730   sym(1).Node = node;
2731 } break;
2732 ./
2733
2734 CaseClauses: CaseClause ;
2735 /.
2736 case $rule_number: {
2737   sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause);
2738 } break;
2739 ./
2740
2741 CaseClauses: CaseClauses CaseClause ;
2742 /.
2743 case $rule_number: {
2744   sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause);
2745 } break;
2746 ./
2747
2748 CaseClausesOpt: ;
2749 /.
2750 case $rule_number: {
2751   sym(1).Node = 0;
2752 } break;
2753 ./
2754
2755 CaseClausesOpt: CaseClauses ;
2756 /.
2757 case $rule_number: {
2758   sym(1).Node = sym(1).CaseClauses->finish ();
2759 } break;
2760 ./
2761
2762 CaseClause: T_CASE Expression T_COLON StatementListOpt ;
2763 /.
2764 case $rule_number: {
2765   AST::CaseClause *node = makeAstNode<AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList);
2766   node->caseToken = loc(1);
2767   node->colonToken = loc(3);
2768   sym(1).Node = node;
2769 } break;
2770 ./
2771
2772 DefaultClause: T_DEFAULT T_COLON StatementListOpt ;
2773 /.
2774 case $rule_number: {
2775   AST::DefaultClause *node = makeAstNode<AST::DefaultClause> (driver->nodePool(), sym(3).StatementList);
2776   node->defaultToken = loc(1);
2777   node->colonToken = loc(2);
2778   sym(1).Node = node;
2779 } break;
2780 ./
2781
2782 LabelledStatement: T_SIGNAL T_COLON Statement ;
2783 /.case $rule_number:./
2784
2785 LabelledStatement: T_PROPERTY T_COLON Statement ;
2786 /.
2787 case $rule_number: {
2788   AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()), sym(3).Statement);
2789   node->identifierToken = loc(1);
2790   node->colonToken = loc(2);
2791   sym(1).Node = node;
2792 } break;
2793 ./
2794
2795 LabelledStatement: T_IDENTIFIER T_COLON Statement ;
2796 /.
2797 case $rule_number: {
2798   AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement);
2799   node->identifierToken = loc(1);
2800   node->colonToken = loc(2);
2801   sym(1).Node = node;
2802 } break;
2803 ./
2804
2805 ThrowStatement: T_THROW Expression T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
2806 ThrowStatement: T_THROW Expression T_SEMICOLON ;
2807 /.
2808 case $rule_number: {
2809   AST::ThrowStatement *node = makeAstNode<AST::ThrowStatement> (driver->nodePool(), sym(2).Expression);
2810   node->throwToken = loc(1);
2811   node->semicolonToken = loc(3);
2812   sym(1).Node = node;
2813 } break;
2814 ./
2815
2816 TryStatement: T_TRY Block Catch ;
2817 /.
2818 case $rule_number: {
2819   AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch);
2820   node->tryToken = loc(1);
2821   sym(1).Node = node;
2822 } break;
2823 ./
2824
2825 TryStatement: T_TRY Block Finally ;
2826 /.
2827 case $rule_number: {
2828   AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally);
2829   node->tryToken = loc(1);
2830   sym(1).Node = node;
2831 } break;
2832 ./
2833
2834 TryStatement: T_TRY Block Catch Finally ;
2835 /.
2836 case $rule_number: {
2837   AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally);
2838   node->tryToken = loc(1);
2839   sym(1).Node = node;
2840 } break;
2841 ./
2842
2843 Catch: T_CATCH T_LPAREN JsIdentifier T_RPAREN Block ;
2844 /.
2845 case $rule_number: {
2846   AST::Catch *node = makeAstNode<AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Block);
2847   node->catchToken = loc(1);
2848   node->lparenToken = loc(2);
2849   node->identifierToken = loc(3);
2850   node->rparenToken = loc(4);
2851   sym(1).Node = node;
2852 } break;
2853 ./
2854
2855 Finally: T_FINALLY Block ;
2856 /.
2857 case $rule_number: {
2858   AST::Finally *node = makeAstNode<AST::Finally> (driver->nodePool(), sym(2).Block);
2859   node->finallyToken = loc(1);
2860   sym(1).Node = node;
2861 } break;
2862 ./
2863
2864 DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2865 DebuggerStatement: T_DEBUGGER T_SEMICOLON ;
2866 /.
2867 case $rule_number: {
2868   AST::DebuggerStatement *node = makeAstNode<AST::DebuggerStatement> (driver->nodePool());
2869   node->debuggerToken = loc(1);
2870   node->semicolonToken = loc(2);
2871   sym(1).Node = node;
2872 } break;
2873 ./
2874
2875 FunctionDeclaration: T_FUNCTION JsIdentifier T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
2876 /.
2877 case $rule_number: {
2878   AST::FunctionDeclaration *node = makeAstNode<AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
2879   node->functionToken = loc(1);
2880   node->identifierToken = loc(2);
2881   node->lparenToken = loc(3);
2882   node->rparenToken = loc(5);
2883   node->lbraceToken = loc(6);
2884   node->rbraceToken = loc(8);
2885   sym(1).Node = node;
2886 } break;
2887 ./
2888
2889 FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
2890 /.
2891 case $rule_number: {
2892   AST::FunctionExpression *node = makeAstNode<AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
2893   node->functionToken = loc(1);
2894   if (sym(2).sval)
2895       node->identifierToken = loc(2);
2896   node->lparenToken = loc(3);
2897   node->rparenToken = loc(5);
2898   node->lbraceToken = loc(6);
2899   node->rbraceToken = loc(8);
2900   sym(1).Node = node;
2901 } break;
2902 ./
2903
2904 FormalParameterList: JsIdentifier ;
2905 /.
2906 case $rule_number: {
2907   AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).sval);
2908   node->identifierToken = loc(1);
2909   sym(1).Node = node;
2910 } break;
2911 ./
2912
2913 FormalParameterList: FormalParameterList T_COMMA JsIdentifier ;
2914 /.
2915 case $rule_number: {
2916   AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval);
2917   node->commaToken = loc(2);
2918   node->identifierToken = loc(3);
2919   sym(1).Node = node;
2920 } break;
2921 ./
2922
2923 FormalParameterListOpt: ;
2924 /.
2925 case $rule_number: {
2926   sym(1).Node = 0;
2927 } break;
2928 ./
2929
2930 FormalParameterListOpt: FormalParameterList ;
2931 /.
2932 case $rule_number: {
2933   sym(1).Node = sym(1).FormalParameterList->finish ();
2934 } break;
2935 ./
2936
2937 FunctionBodyOpt: ;
2938 /.
2939 case $rule_number: {
2940   sym(1).Node = 0;
2941 } break;
2942 ./
2943
2944 FunctionBodyOpt: FunctionBody ;
2945
2946 FunctionBody: SourceElements ;
2947 /.
2948 case $rule_number: {
2949   sym(1).Node = makeAstNode<AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ());
2950 } break;
2951 ./
2952
2953 Program: SourceElements ;
2954 /.
2955 case $rule_number: {
2956   sym(1).Node = makeAstNode<AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ());
2957 } break;
2958 ./
2959
2960 SourceElements: SourceElement ;
2961 /.
2962 case $rule_number: {
2963   sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElement);
2964 } break;
2965 ./
2966
2967 SourceElements: SourceElements SourceElement ;
2968 /.
2969 case $rule_number: {
2970   sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement);
2971 } break;
2972 ./
2973
2974 SourceElement: Statement ;
2975 /.
2976 case $rule_number: {
2977   sym(1).Node = makeAstNode<AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement);
2978 } break;
2979 ./
2980
2981 SourceElement: FunctionDeclaration ;
2982 /.
2983 case $rule_number: {
2984   sym(1).Node = makeAstNode<AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration);
2985 } break;
2986 ./
2987
2988 IdentifierOpt: ;
2989 /.
2990 case $rule_number: {
2991   sym(1).sval = 0;
2992 } break;
2993 ./
2994
2995 IdentifierOpt: JsIdentifier ;
2996
2997 PropertyNameAndValueListOpt: ;
2998 /.
2999 case $rule_number: {
3000   sym(1).Node = 0;
3001 } break;
3002 ./
3003
3004 PropertyNameAndValueListOpt: PropertyNameAndValueList ;
3005
3006 /.
3007             } // switch
3008             action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
3009         } // if
3010     } while (action != 0);
3011
3012     if (first_token == last_token) {
3013         const int errorState = state_stack[tos];
3014
3015         // automatic insertion of `;'
3016         if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && automatic(driver, yytoken)) {
3017             SavedToken &tk = token_buffer[0];
3018             tk.token = yytoken;
3019             tk.dval = yylval;
3020             tk.loc = yylloc;
3021
3022             yylloc = yyprevlloc;
3023             yylloc.offset += yylloc.length;
3024             yylloc.startColumn += yylloc.length;
3025             yylloc.length = 0;
3026
3027             //const QString msg = qApp->translate("QmlParser", "Missing `;'");
3028             //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
3029
3030             first_token = &token_buffer[0];
3031             last_token = &token_buffer[1];
3032
3033             yytoken = T_SEMICOLON;
3034             yylval = 0;
3035
3036             action = errorState;
3037
3038             goto _Lcheck_token;
3039         }
3040
3041         hadErrors = true;
3042
3043         token_buffer[0].token = yytoken;
3044         token_buffer[0].dval = yylval;
3045         token_buffer[0].loc = yylloc;
3046
3047         token_buffer[1].token = yytoken = lexer->lex();
3048         token_buffer[1].dval  = yylval  = lexer->dval();
3049         token_buffer[1].loc   = yylloc  = location(lexer);
3050
3051         if (t_action(errorState, yytoken)) {
3052             QString msg;
3053             int token = token_buffer[0].token;
3054             if (token < 0 || token >= TERMINAL_COUNT)
3055                 msg = qApp->translate("QmlParser", "Syntax error");
3056             else
3057                 msg = qApp->translate("QmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
3058             diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
3059
3060             action = errorState;
3061             goto _Lcheck_token;
3062         }
3063
3064         static int tokens[] = {
3065             T_PLUS,
3066             T_EQ,
3067
3068             T_COMMA,
3069             T_COLON,
3070             T_SEMICOLON,
3071
3072             T_RPAREN, T_RBRACKET, T_RBRACE,
3073
3074             T_NUMERIC_LITERAL,
3075             T_IDENTIFIER,
3076
3077             T_LPAREN, T_LBRACKET, T_LBRACE,
3078
3079             EOF_SYMBOL
3080         };
3081
3082         for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
3083             int a = t_action(errorState, *tk);
3084             if (a > 0 && t_action(a, yytoken)) {
3085                 const QString msg = qApp->translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
3086                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
3087
3088                 yytoken = *tk;
3089                 yylval = 0;
3090                 yylloc = token_buffer[0].loc;
3091                 yylloc.length = 0;
3092
3093                 first_token = &token_buffer[0];
3094                 last_token = &token_buffer[2];
3095
3096                 action = errorState;
3097                 goto _Lcheck_token;
3098             }
3099         }
3100
3101         for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
3102             if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
3103                 tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION ||
3104                 tk == T_FEED_JS_SOURCE_ELEMENT)
3105                continue;
3106
3107             int a = t_action(errorState, tk);
3108             if (a > 0 && t_action(a, yytoken)) {
3109                 const QString msg = qApp->translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
3110                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
3111
3112                 yytoken = tk;
3113                 yylval = 0;
3114                 yylloc = token_buffer[0].loc;
3115                 yylloc.length = 0;
3116
3117                 action = errorState;
3118                 goto _Lcheck_token;
3119             }
3120         }
3121
3122         const QString msg = qApp->translate("QmlParser", "Syntax error");
3123         diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
3124     }
3125
3126     return false;
3127 }
3128
3129 QT_QML_END_NAMESPACE
3130
3131
3132 ./
3133 /:
3134 QT_QML_END_NAMESPACE
3135
3136
3137
3138 #endif // QMLJSPARSER_P_H
3139 :/