src/declarative/qml/parser/qdeclarativejs.g

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