src/qml/qml/parser/qqmljs.g

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