src/declarative/qml/parser/qdeclarativejs.g

   1 ----------------------------------------------------------------------------
   2 --
   3 -- Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 -- All rights reserved.
   5 -- Contact: Nokia Corporation (qt-info@nokia.com)
   6 --
   7 -- This file is part of the QtDeclarative module of the Qt Toolkit.
   8 --
   9 -- $QT_BEGIN_LICENSE:LGPL-ONLY$
  10 -- GNU Lesser General Public License Usage
  11 -- This file may be used under the terms of the GNU Lesser
  12 -- General Public License version 2.1 as published by the Free Software
  13 -- Foundation and appearing in the file LICENSE.LGPL included in the
  14 -- packaging of this file.  Please review the following information to
  15 -- ensure the GNU Lesser General Public License version 2.1 requirements
  16 -- will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 --
  18 -- If you have questions regarding the use of this file, please contact
  19 -- Nokia at qt-info@nokia.com.
  20 -- $QT_END_LICENSE$
  21 --
  22 ----------------------------------------------------------------------------
  23
  24 %parser         QDeclarativeJSGrammar
  25 %decl           qdeclarativejsparser_p.h
  26 %impl           qdeclarativejsparser.cpp
  27 %expect         2
  28 %expect-rr      2
  29
  30 %token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="
  31 %token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"
  32 %token T_COLON ":"              T_COMMA ","                 T_CONTINUE "continue"
  33 %token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"
  34 %token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."
  35 %token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="
  36 %token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"
  37 %token T_FUNCTION "function"    T_GE ">="                   T_GT ">"
  38 %token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"
  39 %token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"
  40 %token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"
  41 %token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("
  42 %token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="
  43 %token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"
  44 %token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="
  45 %token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"
  46 %token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"
  47 %token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"
  48 %token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"
  49 %token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"
  50 %token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"
  51 %token T_STAR_EQ "*="           T_STRING_LITERAL "string literal"
  52 %token T_PROPERTY "property"    T_SIGNAL "signal"           T_READONLY "readonly"
  53 %token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"
  54 %token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"
  55 %token T_VAR "var"              T_VOID "void"               T_WHILE "while"
  56 %token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="
  57 %token T_NULL "null"            T_TRUE "true"               T_FALSE "false"
  58 %token T_CONST "const"
  59 %token T_DEBUGGER "debugger"
  60 %token T_RESERVED_WORD "reserved word"
  61 %token T_MULTILINE_STRING_LITERAL "multiline string literal"
  62 %token T_COMMENT "comment"
  63
  64 --- context keywords.
  65 %token T_PUBLIC "public"
  66 %token T_IMPORT "import"
  67 %token T_AS "as"
  68 %token T_ON "on"
  69
  70 %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) 2011 Nokia Corporation and/or its subsidiary(-ies).
  89 ** All rights reserved.
  90 ** Contact: Nokia Corporation (qt-info@nokia.com)
  91 **
  92 ** This file is part of the QtDeclarative module of the Qt Toolkit.
  93 **
  94 ** $QT_BEGIN_LICENSE:LGPL$
  95 ** GNU Lesser General Public License Usage
  96 ** This file may be used under the terms of the GNU Lesser General Public
  97 ** License version 2.1 as published by the Free Software Foundation and
  98 ** appearing in the file LICENSE.LGPL included in the packaging of this
  99 ** file. Please review the following information to ensure the GNU Lesser
 100 ** General Public License version 2.1 requirements will be met:
 101 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 102 **
 103 ** In addition, as a special exception, Nokia gives you certain additional
 104 ** rights. These rights are described in the Nokia Qt LGPL Exception
 105 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 106 **
 107 ** GNU General Public License Usage
 108 ** Alternatively, this file may be used under the terms of the GNU General
 109 ** Public License version 3.0 as published by the Free Software Foundation
 110 ** and appearing in the file LICENSE.GPL included in the packaging of this
 111 ** file. Please review the following information to ensure the GNU General
 112 ** Public License version 3.0 requirements will be met:
 113 ** http://www.gnu.org/copyleft/gpl.html.
 114 **
 115 ** Other Usage
 116 ** Alternatively, this file may be used in accordance with the terms and
 117 ** conditions contained in a signed written agreement between you and Nokia.
 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) 2011 Nokia Corporation and/or its subsidiary(-ies).
 142 ** All rights reserved.
 143 ** Contact: Nokia Corporation (qt-info@nokia.com)
 144 **
 145 ** This file is part of the QtDeclarative module of the Qt Toolkit.
 146 **
 147 ** $QT_BEGIN_LICENSE:LGPL$
 148 ** GNU Lesser General Public License Usage
 149 ** This file may be used under the terms of the GNU Lesser General Public
 150 ** License version 2.1 as published by the Free Software Foundation and
 151 ** appearing in the file LICENSE.LGPL included in the packaging of this
 152 ** file. Please review the following information to ensure the GNU Lesser
 153 ** General Public License version 2.1 requirements will be met:
 154 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 155 **
 156 ** In addition, as a special exception, Nokia gives you certain additional
 157 ** rights. These rights are described in the Nokia Qt LGPL Exception
 158 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 159 **
 160 ** GNU General Public License Usage
 161 ** Alternatively, this file may be used under the terms of the GNU General
 162 ** Public License version 3.0 as published by the Free Software Foundation
 163 ** and appearing in the file LICENSE.GPL included in the packaging of this
 164 ** file. Please review the following information to ensure the GNU General
 165 ** Public License version 3.0 requirements will be met:
 166 ** http://www.gnu.org/copyleft/gpl.html.
 167 **
 168 ** Other Usage
 169 ** Alternatively, this file may be used in accordance with the terms and
 170 ** conditions contained in a signed written agreement between you and Nokia.
 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       AST::UiSignature *UiSignature;
 259       AST::UiFormalList *UiFormalList;
 260       AST::UiFormal *UiFormal;
 261     };
 262
 263 public:
 264     Parser(Engine *engine);
 265     ~Parser();
 266
 267     // parse a UI program
 268     bool parse() { return parse(T_FEED_UI_PROGRAM); }
 269     bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }
 270     bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }
 271     bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); }
 272     bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); }
 273     bool parseProgram() { return parse(T_FEED_JS_PROGRAM); }
 274
 275     AST::UiProgram *ast() const
 276     { return AST::cast<AST::UiProgram *>(program); }
 277
 278     AST::Statement *statement() const
 279     {
 280         if (! program)
 281             return 0;
 282
 283         return program->statementCast();
 284     }
 285
 286     AST::ExpressionNode *expression() const
 287     {
 288         if (! program)
 289             return 0;
 290
 291         return program->expressionCast();
 292     }
 293
 294     AST::UiObjectMember *uiObjectMember() const
 295     {
 296         if (! program)
 297             return 0;
 298
 299         return program->uiObjectMemberCast();
 300     }
 301
 302     AST::Node *rootNode() const
 303     { return program; }
 304
 305     QList<DiagnosticMessage> diagnosticMessages() const
 306     { return diagnostic_messages; }
 307
 308     inline DiagnosticMessage diagnosticMessage() const
 309     {
 310         foreach (const DiagnosticMessage &d, diagnostic_messages) {
 311             if (! d.kind == DiagnosticMessage::Warning)
 312                 return d;
 313         }
 314
 315         return DiagnosticMessage();
 316     }
 317
 318     inline QString errorMessage() const
 319     { return diagnosticMessage().message; }
 320
 321     inline int errorLineNumber() const
 322     { return diagnosticMessage().loc.startLine; }
 323
 324     inline int errorColumnNumber() const
 325     { return diagnosticMessage().loc.startColumn; }
 326
 327 protected:
 328     bool parse(int startToken);
 329
 330     void reallocateStack();
 331
 332     inline Value &sym(int index)
 333     { return sym_stack [tos + index - 1]; }
 334
 335     inline QStringRef &stringRef(int index)
 336     { return string_stack [tos + index - 1]; }
 337
 338     inline AST::SourceLocation &loc(int index)
 339     { return location_stack [tos + index - 1]; }
 340
 341     AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);
 342
 343 protected:
 344     Engine *driver;
 345     MemoryPool *pool;
 346     int tos;
 347     int stack_size;
 348     Value *sym_stack;
 349     int *state_stack;
 350     AST::SourceLocation *location_stack;
 351     QStringRef *string_stack;
 352
 353     AST::Node *program;
 354
 355     // error recovery
 356     enum { TOKEN_BUFFER_SIZE = 3 };
 357
 358     struct SavedToken {
 359        int token;
 360        double dval;
 361        AST::SourceLocation loc;
 362        QStringRef spell;
 363     };
 364
 365     double yylval;
 366     QStringRef yytokenspell;
 367     AST::SourceLocation yylloc;
 368     AST::SourceLocation yyprevlloc;
 369
 370     SavedToken token_buffer[TOKEN_BUFFER_SIZE];
 371     SavedToken *first_token;
 372     SavedToken *last_token;
 373
 374     QList<DiagnosticMessage> diagnostic_messages;
 375 };
 376
 377 } // end of namespace QDeclarativeJS
 378
 379
 380 :/
 381
 382
 383 /.
 384
 385 #include "qdeclarativejsparser_p.h"
 386 #include <QVarLengthArray>
 387
 388 //
 389 // This file is automatically generated from qmljs.g.
 390 // Changes will be lost.
 391 //
 392
 393 using namespace QDeclarativeJS;
 394
 395 QT_QML_BEGIN_NAMESPACE
 396
 397 void Parser::reallocateStack()
 398 {
 399     if (! stack_size)
 400         stack_size = 128;
 401     else
 402         stack_size <<= 1;
 403
 404     sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
 405     state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
 406     location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
 407     string_stack = reinterpret_cast<QStringRef*> (qRealloc(string_stack, stack_size * sizeof(QStringRef)));
 408 }
 409
 410 Parser::Parser(Engine *engine):
 411     driver(engine),
 412     pool(engine->pool()),
 413     tos(0),
 414     stack_size(0),
 415     sym_stack(0),
 416     state_stack(0),
 417     location_stack(0),
 418     string_stack(0),
 419     first_token(0),
 420     last_token(0)
 421 {
 422 }
 423
 424 Parser::~Parser()
 425 {
 426     if (stack_size) {
 427         qFree(sym_stack);
 428         qFree(state_stack);
 429         qFree(location_stack);
 430         qFree(string_stack);
 431     }
 432 }
 433
 434 static inline AST::SourceLocation location(Lexer *lexer)
 435 {
 436     AST::SourceLocation loc;
 437     loc.offset = lexer->tokenOffset();
 438     loc.length = lexer->tokenLength();
 439     loc.startLine = lexer->tokenStartLine();
 440     loc.startColumn = lexer->tokenStartColumn();
 441     return loc;
 442 }
 443
 444 AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
 445 {
 446     QVarLengthArray<QStringRef, 4> nameIds;
 447     QVarLengthArray<AST::SourceLocation, 4> locations;
 448
 449     AST::ExpressionNode *it = expr;
 450     while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
 451         nameIds.append(m->name);
 452         locations.append(m->identifierToken);
 453         it = m->base;
 454     }
 455
 456     if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
 457         AST::UiQualifiedId *q = new (pool) AST::UiQualifiedId(idExpr->name);
 458         q->identifierToken = idExpr->identifierToken;
 459
 460         AST::UiQualifiedId *currentId = q;
 461         for (int i = nameIds.size() - 1; i != -1; --i) {
 462             currentId = new (pool) AST::UiQualifiedId(currentId, nameIds[i]);
 463             currentId->identifierToken = locations[i];
 464         }
 465
 466         return currentId->finish();
 467     }
 468
 469     return 0;
 470 }
 471
 472 bool Parser::parse(int startToken)
 473 {
 474     Lexer *lexer = driver->lexer();
 475     bool hadErrors = false;
 476     int yytoken = -1;
 477     int action = 0;
 478
 479     token_buffer[0].token = startToken;
 480     first_token = &token_buffer[0];
 481     last_token = &token_buffer[1];
 482
 483     tos = -1;
 484     program = 0;
 485
 486     do {
 487         if (++tos == stack_size)
 488             reallocateStack();
 489
 490         state_stack[tos] = action;
 491
 492     _Lcheck_token:
 493         if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
 494             yyprevlloc = yylloc;
 495
 496             if (first_token == last_token) {
 497                 yytoken = lexer->lex();
 498                 yylval = lexer->tokenValue();
 499                 yytokenspell = lexer->tokenSpell();
 500                 yylloc = location(lexer);
 501             } else {
 502                 yytoken = first_token->token;
 503                 yylval = first_token->dval;
 504                 yytokenspell = first_token->spell;
 505                 yylloc = first_token->loc;
 506                 ++first_token;
 507             }
 508         }
 509
 510         action = t_action(action, yytoken);
 511         if (action > 0) {
 512             if (action != ACCEPT_STATE) {
 513                 yytoken = -1;
 514                 sym(1).dval = yylval;
 515                 stringRef(1) = yytokenspell;
 516                 loc(1) = yylloc;
 517             } else {
 518               --tos;
 519               return ! hadErrors;
 520             }
 521         } else if (action < 0) {
 522           const int r = -action - 1;
 523           tos -= rhs[r];
 524
 525           switch (r) {
 526 ./
 527
 528 --------------------------------------------------------------------------------------------------------
 529 -- Declarative UI
 530 --------------------------------------------------------------------------------------------------------
 531
 532 TopLevel: T_FEED_UI_PROGRAM UiProgram ;
 533 /.
 534 case $rule_number: {
 535   sym(1).Node = sym(2).Node;
 536   program = sym(1).Node;
 537 } break;
 538 ./
 539
 540 TopLevel: T_FEED_JS_STATEMENT Statement ;
 541 /.
 542 case $rule_number: {
 543   sym(1).Node = sym(2).Node;
 544   program = sym(1).Node;
 545 } break;
 546 ./
 547
 548 TopLevel: T_FEED_JS_EXPRESSION Expression ;
 549 /.
 550 case $rule_number: {
 551   sym(1).Node = sym(2).Node;
 552   program = sym(1).Node;
 553 } break;
 554 ./
 555
 556 TopLevel: T_FEED_JS_SOURCE_ELEMENT SourceElement ;
 557 /.
 558 case $rule_number: {
 559   sym(1).Node = sym(2).Node;
 560   program = sym(1).Node;
 561 } break;
 562 ./
 563
 564 TopLevel: T_FEED_UI_OBJECT_MEMBER UiObjectMember ;
 565 /.
 566 case $rule_number: {
 567   sym(1).Node = sym(2).Node;
 568   program = sym(1).Node;
 569 } break;
 570 ./
 571
 572 TopLevel: T_FEED_JS_PROGRAM Program ;
 573 /.
 574 case $rule_number: {
 575   sym(1).Node = sym(2).Node;
 576   program = sym(1).Node;
 577 } break;
 578 ./
 579
 580 UiProgram: UiImportListOpt UiRootMember ;
 581 /.
 582 case $rule_number: {
 583   sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiImportList,
 584         sym(2).UiObjectMemberList->finish());
 585 } break;
 586 ./
 587
 588 UiImportListOpt: Empty ;
 589 UiImportListOpt: UiImportList ;
 590 /.
 591 case $rule_number: {
 592     sym(1).Node = sym(1).UiImportList->finish();
 593 } break;
 594 ./
 595
 596 UiImportList: UiImport ;
 597 /.
 598 case $rule_number: {
 599     sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImport);
 600 } break;
 601 ./
 602
 603 UiImportList: UiImportList UiImport ;
 604 /.
 605 case $rule_number: {
 606     sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImportList, sym(2).UiImport);
 607 } break;
 608 ./
 609
 610 ImportId: MemberExpression ;
 611
 612 UiImport: UiImportHead T_AUTOMATIC_SEMICOLON ;
 613 UiImport: UiImportHead T_SEMICOLON ;
 614 /.
 615 case $rule_number: {
 616     sym(1).UiImport->semicolonToken = loc(2);
 617 } break;
 618 ./
 619
 620 UiImport: UiImportHead T_NUMERIC_LITERAL T_AUTOMATIC_SEMICOLON ;
 621 UiImport: UiImportHead T_NUMERIC_LITERAL T_SEMICOLON ;
 622 /.
 623 case $rule_number: {
 624     sym(1).UiImport->versionToken = loc(2);
 625     sym(1).UiImport->semicolonToken = loc(3);
 626 } break;
 627 ./
 628
 629 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
 630 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_SEMICOLON ;
 631 /.
 632 case $rule_number: {
 633     sym(1).UiImport->versionToken = loc(2);
 634     sym(1).UiImport->asToken = loc(3);
 635     sym(1).UiImport->importIdToken = loc(4);
 636     sym(1).UiImport->importId = stringRef(4);
 637     sym(1).UiImport->semicolonToken = loc(5);
 638 } break;
 639 ./
 640
 641 UiImport: UiImportHead T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
 642 UiImport: UiImportHead T_AS JsIdentifier T_SEMICOLON ;
 643 /.
 644 case $rule_number: {
 645     sym(1).UiImport->asToken = loc(2);
 646     sym(1).UiImport->importIdToken = loc(3);
 647     sym(1).UiImport->importId = stringRef(3);
 648     sym(1).UiImport->semicolonToken = loc(4);
 649 } break;
 650 ./
 651
 652
 653 UiImportHead: T_IMPORT ImportId ;
 654 /.
 655 case $rule_number: {
 656     AST::UiImport *node = 0;
 657
 658     if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
 659         node = new (pool) AST::UiImport(importIdLiteral->value);
 660         node->fileNameToken = loc(2);
 661     } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
 662         node = new (pool) AST::UiImport(qualifiedId);
 663         node->fileNameToken = loc(2);
 664     }
 665
 666     sym(1).Node = node;
 667
 668     if (node) {
 669         node->importToken = loc(1);
 670     } else {
 671        diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
 672          QLatin1String("Expected a qualified name id or a string literal")));
 673
 674         return false; // ### remove me
 675     }
 676 } break;
 677 ./
 678
 679 Empty: ;
 680 /.
 681 case $rule_number: {
 682     sym(1).Node = 0;
 683 } break;
 684 ./
 685
 686 UiRootMember: UiObjectDefinition ;
 687 /.
 688 case $rule_number: {
 689     sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
 690 } break;
 691 ./
 692
 693 UiObjectMemberList: UiObjectMember ;
 694 /.
 695 case $rule_number: {
 696     sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
 697 } break;
 698 ./
 699
 700 UiObjectMemberList: UiObjectMemberList UiObjectMember ;
 701 /.
 702 case $rule_number: {
 703     AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(
 704         sym(1).UiObjectMemberList, sym(2).UiObjectMember);
 705     sym(1).Node = node;
 706 } break;
 707 ./
 708
 709 UiArrayMemberList: UiObjectDefinition ;
 710 /.
 711 case $rule_number: {
 712     sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
 713 } break;
 714 ./
 715
 716 UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ;
 717 /.
 718 case $rule_number: {
 719     AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(
 720         sym(1).UiArrayMemberList, sym(3).UiObjectMember);
 721     node->commaToken = loc(2);
 722     sym(1).Node = node;
 723 } break;
 724 ./
 725
 726 UiObjectInitializer: T_LBRACE T_RBRACE ;
 727 /.
 728 case $rule_number: {
 729     AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
 730     node->lbraceToken = loc(1);
 731     node->rbraceToken = loc(2);
 732     sym(1).Node = node;
 733 }   break;
 734 ./
 735
 736 UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ;
 737 /.
 738 case $rule_number: {
 739     AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish());
 740     node->lbraceToken = loc(1);
 741     node->rbraceToken = loc(3);
 742     sym(1).Node = node;
 743 }   break;
 744 ./
 745
 746 UiObjectDefinition: UiQualifiedId UiObjectInitializer ;
 747 /.
 748 case $rule_number: {
 749     AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId,
 750         sym(2).UiObjectInitializer);
 751     sym(1).Node = node;
 752 }   break;
 753 ./
 754
 755 UiObjectMember: UiObjectDefinition ;
 756
 757 UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
 758 /.
 759 case $rule_number: {
 760     AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(
 761         sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
 762     node->colonToken = loc(2);
 763     node->lbracketToken = loc(3);
 764     node->rbracketToken = loc(5);
 765     sym(1).Node = node;
 766 }   break;
 767 ./
 768
 769 UiObjectMember: UiQualifiedId             T_COLON UiQualifiedId  UiObjectInitializer ;
 770 /.
 771 case $rule_number: {
 772     AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
 773       sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
 774     node->colonToken = loc(2);
 775     sym(1).Node = node;
 776 } break;
 777 ./
 778
 779 UiObjectMember: UiQualifiedId             T_ON UiQualifiedId  UiObjectInitializer ;
 780 /.
 781 case $rule_number: {
 782     AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
 783       sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
 784     node->colonToken = loc(2);
 785     node->hasOnToken = true;
 786     sym(1).Node = node;
 787 } break;
 788 ./
 789
 790 UiScriptStatement: Block ;
 791 UiScriptStatement: EmptyStatement ;
 792 UiScriptStatement: ExpressionStatement ;
 793 UiScriptStatement: IfStatement ;
 794 UiScriptStatement: WithStatement ;
 795 UiScriptStatement: SwitchStatement ;
 796 UiScriptStatement: TryStatement ;
 797
 798 UiObjectMember: UiQualifiedId T_COLON UiScriptStatement ;
 799 /.
 800 case $rule_number:
 801 {
 802     AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(
 803         sym(1).UiQualifiedId, sym(3).Statement);
 804     node->colonToken = loc(2);
 805     sym(1).Node = node;
 806 }   break;
 807 ./
 808
 809 UiPropertyType: T_VAR ;
 810 UiPropertyType: T_RESERVED_WORD ;
 811 UiPropertyType: T_IDENTIFIER ;
 812
 813 UiParameterListOpt: ;
 814 /.
 815 case $rule_number: {
 816   sym(1).Node = 0;
 817 } break;
 818 ./
 819
 820 UiParameterListOpt: UiParameterList ;
 821 /.
 822 case $rule_number: {
 823   sym(1).Node = sym(1).UiParameterList->finish ();
 824 } break;
 825 ./
 826
 827 UiParameterList: UiPropertyType JsIdentifier ;
 828 /.
 829 case $rule_number: {
 830   AST::UiParameterList *node = new (pool) AST::UiParameterList(stringRef(1), stringRef(2));
 831   node->identifierToken = loc(2);
 832   sym(1).Node = node;
 833 } break;
 834 ./
 835
 836 UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ;
 837 /.
 838 case $rule_number: {
 839   AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, stringRef(3), stringRef(4));
 840   node->commaToken = loc(2);
 841   node->identifierToken = loc(4);
 842   sym(1).Node = node;
 843 } break;
 844 ./
 845
 846 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_AUTOMATIC_SEMICOLON ;
 847 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ;
 848 /.
 849 case $rule_number: {
 850     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
 851     node->type = AST::UiPublicMember::Signal;
 852     node->propertyToken = loc(1);
 853     node->typeToken = loc(2);
 854     node->identifierToken = loc(2);
 855     node->parameters = sym(4).UiParameterList;
 856     node->semicolonToken = loc(6);
 857     sym(1).Node = node;
 858 }   break;
 859 ./
 860
 861 UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;
 862 UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ;
 863 /.
 864 case $rule_number: {
 865     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
 866     node->type = AST::UiPublicMember::Signal;
 867     node->propertyToken = loc(1);
 868     node->typeToken = loc(2);
 869     node->identifierToken = loc(2);
 870     node->semicolonToken = loc(3);
 871     sym(1).Node = node;
 872 }   break;
 873 ./
 874
 875 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_AUTOMATIC_SEMICOLON ;
 876 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ;
 877 /.
 878 case $rule_number: {
 879     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
 880     node->typeModifier = stringRef(2);
 881     node->propertyToken = loc(1);
 882     node->typeModifierToken = loc(2);
 883     node->typeToken = loc(4);
 884     node->identifierToken = loc(6);
 885     node->semicolonToken = loc(7);
 886     sym(1).Node = node;
 887 }   break;
 888 ./
 889
 890 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
 891 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
 892 /.
 893 case $rule_number: {
 894     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
 895     node->propertyToken = loc(1);
 896     node->typeToken = loc(2);
 897     node->identifierToken = loc(3);
 898     node->semicolonToken = loc(4);
 899     sym(1).Node = node;
 900 }   break;
 901 ./
 902
 903 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
 904 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
 905 /.
 906 case $rule_number: {
 907     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4));
 908     node->isDefaultMember = true;
 909     node->defaultToken = loc(1);
 910     node->propertyToken = loc(2);
 911     node->typeToken = loc(3);
 912     node->identifierToken = loc(4);
 913     node->semicolonToken = loc(5);
 914     sym(1).Node = node;
 915 }   break;
 916 ./
 917
 918 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
 919 /.
 920 case $rule_number: {
 921     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3),
 922         sym(5).Statement);
 923     node->propertyToken = loc(1);
 924     node->typeToken = loc(2);
 925     node->identifierToken = loc(3);
 926     node->colonToken = loc(4);
 927     sym(1).Node = node;
 928 }   break;
 929 ./
 930
 931 UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
 932 /.
 933 case $rule_number: {
 934     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
 935         sym(6).Statement);
 936     node->isReadonlyMember = true;
 937     node->readonlyToken = loc(1);
 938     node->propertyToken = loc(2);
 939     node->typeToken = loc(3);
 940     node->identifierToken = loc(4);
 941     node->colonToken = loc(5);
 942     sym(1).Node = node;
 943 }   break;
 944 ./
 945
 946 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
 947 /.
 948 case $rule_number: {
 949     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
 950         sym(6).Statement);
 951     node->isDefaultMember = true;
 952     node->defaultToken = loc(1);
 953     node->propertyToken = loc(2);
 954     node->typeToken = loc(3);
 955     node->identifierToken = loc(4);
 956     node->colonToken = loc(5);
 957     sym(1).Node = node;
 958 }   break;
 959 ./
 960
 961 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
 962 /.
 963 case $rule_number: {
 964     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
 965     node->typeModifier = stringRef(2);
 966     node->propertyToken = loc(1);
 967     node->typeModifierToken = loc(2);
 968     node->typeToken = loc(4);
 969     node->identifierToken = loc(6);
 970     node->semicolonToken = loc(7); // insert a fake ';' before ':'
 971
 972     AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(6));
 973     propertyName->identifierToken = loc(6);
 974     propertyName->next = 0;
 975
 976     AST::UiArrayBinding *binding = new (pool) AST::UiArrayBinding(
 977         propertyName, sym(9).UiArrayMemberList->finish());
 978     binding->colonToken = loc(7);
 979     binding->lbracketToken = loc(8);
 980     binding->rbracketToken = loc(10);
 981
 982     node->binding = binding;
 983
 984     sym(1).Node = node;
 985 }   break;
 986 ./
 987
 988 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ;
 989 /.
 990 case $rule_number: {
 991     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
 992     node->propertyToken = loc(1);
 993     node->typeToken = loc(2);
 994     node->identifierToken = loc(3);
 995     node->semicolonToken = loc(4); // insert a fake ';' before ':'
 996
 997     AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(3));
 998     propertyName->identifierToken = loc(3);
 999     propertyName->next = 0;
1000
1001     AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
1002       propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
1003     binding->colonToken = loc(4);
1004
1005     node->binding = binding;
1006
1007     sym(1).Node = node;
1008 }   break;
1009 ./
1010
1011 UiObjectMember: FunctionDeclaration ;
1012 /.
1013 case $rule_number: {
1014     sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
1015 }   break;
1016 ./
1017
1018 UiObjectMember: VariableStatement ;
1019 /.
1020 case $rule_number: {
1021     sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
1022 }   break;
1023 ./
1024
1025 JsIdentifier: T_IDENTIFIER;
1026
1027 JsIdentifier: T_PROPERTY ;
1028 JsIdentifier: T_SIGNAL ;
1029 JsIdentifier: T_READONLY ;
1030 JsIdentifier: T_ON ;
1031
1032 --------------------------------------------------------------------------------------------------------
1033 -- Expressions
1034 --------------------------------------------------------------------------------------------------------
1035
1036 PrimaryExpression: T_THIS ;
1037 /.
1038 case $rule_number: {
1039   AST::ThisExpression *node = new (pool) AST::ThisExpression();
1040   node->thisToken = loc(1);
1041   sym(1).Node = node;
1042 } break;
1043 ./
1044
1045 PrimaryExpression: JsIdentifier ;
1046 /.
1047 case $rule_number: {
1048   AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
1049   node->identifierToken = loc(1);
1050   sym(1).Node = node;
1051 } break;
1052 ./
1053
1054 PrimaryExpression: T_NULL ;
1055 /.
1056 case $rule_number: {
1057   AST::NullExpression *node = new (pool) AST::NullExpression();
1058   node->nullToken = loc(1);
1059   sym(1).Node = node;
1060 } break;
1061 ./
1062
1063 PrimaryExpression: T_TRUE ;
1064 /.
1065 case $rule_number: {
1066   AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
1067   node->trueToken = loc(1);
1068   sym(1).Node = node;
1069 } break;
1070 ./
1071
1072 PrimaryExpression: T_FALSE ;
1073 /.
1074 case $rule_number: {
1075   AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
1076   node->falseToken = loc(1);
1077   sym(1).Node = node;
1078 } break;
1079 ./
1080
1081 PrimaryExpression: T_NUMERIC_LITERAL ;
1082 /.
1083 case $rule_number: {
1084   AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
1085   node->literalToken = loc(1);
1086   sym(1).Node = node;
1087 } break;
1088 ./
1089
1090 PrimaryExpression: T_MULTILINE_STRING_LITERAL ;
1091 /.case $rule_number:./
1092
1093 PrimaryExpression: T_STRING_LITERAL ;
1094 /.
1095 case $rule_number: {
1096   AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
1097   node->literalToken = loc(1);
1098   sym(1).Node = node;
1099 } break;
1100 ./
1101
1102 PrimaryExpression: T_DIVIDE_ ;
1103 /:
1104 #define J_SCRIPT_REGEXPLITERAL_RULE1 $rule_number
1105 :/
1106 /.
1107 case $rule_number: {
1108   bool rx = lexer->scanRegExp(Lexer::NoPrefix);
1109   if (!rx) {
1110     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
1111     return false; // ### remove me
1112   }
1113
1114   loc(1).length = lexer->tokenLength();
1115
1116   AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
1117     driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
1118   node->literalToken = loc(1);
1119   sym(1).Node = node;
1120 } break;
1121 ./
1122
1123 PrimaryExpression: T_DIVIDE_EQ ;
1124 /:
1125 #define J_SCRIPT_REGEXPLITERAL_RULE2 $rule_number
1126 :/
1127 /.
1128 case $rule_number: {
1129   bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
1130   if (!rx) {
1131     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
1132     return false;
1133   }
1134
1135   loc(1).length = lexer->tokenLength();
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: SourceElements ;
2826 /.
2827 case $rule_number: {
2828   sym(1).Node = new (pool) AST::Program(sym(1).SourceElements->finish ());
2829 } break;
2830 ./
2831
2832 SourceElements: SourceElement ;
2833 /.
2834 case $rule_number: {
2835   sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElement);
2836 } break;
2837 ./
2838
2839 SourceElements: SourceElements SourceElement ;
2840 /.
2841 case $rule_number: {
2842   sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElements, sym(2).SourceElement);
2843 } break;
2844 ./
2845
2846 SourceElement: Statement ;
2847 /.
2848 case $rule_number: {
2849   sym(1).Node = new (pool) AST::StatementSourceElement(sym(1).Statement);
2850 } break;
2851 ./
2852
2853 SourceElement: FunctionDeclaration ;
2854 /.
2855 case $rule_number: {
2856   sym(1).Node = new (pool) AST::FunctionSourceElement(sym(1).FunctionDeclaration);
2857 } break;
2858 ./
2859
2860 IdentifierOpt: ;
2861 /.
2862 case $rule_number: {
2863   stringRef(1) = QStringRef();
2864 } break;
2865 ./
2866
2867 IdentifierOpt: JsIdentifier ;
2868
2869 PropertyNameAndValueListOpt: ;
2870 /.
2871 case $rule_number: {
2872   sym(1).Node = 0;
2873 } break;
2874 ./
2875
2876 PropertyNameAndValueListOpt: PropertyNameAndValueList ;
2877
2878 /.
2879             } // switch
2880             action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
2881         } // if
2882     } while (action != 0);
2883
2884     if (first_token == last_token) {
2885         const int errorState = state_stack[tos];
2886
2887         // automatic insertion of `;'
2888         if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && lexer->canInsertAutomaticSemicolon(yytoken)) {
2889             SavedToken &tk = token_buffer[0];
2890             tk.token = yytoken;
2891             tk.dval = yylval;
2892             tk.spell = yytokenspell;
2893             tk.loc = yylloc;
2894
2895             yylloc = yyprevlloc;
2896             yylloc.offset += yylloc.length;
2897             yylloc.startColumn += yylloc.length;
2898             yylloc.length = 0;
2899
2900             //const QString msg = qApp->translate("QDeclarativeParser", "Missing `;'");
2901             //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
2902
2903             first_token = &token_buffer[0];
2904             last_token = &token_buffer[1];
2905
2906             yytoken = T_SEMICOLON;
2907             yylval = 0;
2908
2909             action = errorState;
2910
2911             goto _Lcheck_token;
2912         }
2913
2914         hadErrors = true;
2915
2916         token_buffer[0].token = yytoken;
2917         token_buffer[0].dval = yylval;
2918         token_buffer[0].spell = yytokenspell;
2919         token_buffer[0].loc = yylloc;
2920
2921         token_buffer[1].token = yytoken       = lexer->lex();
2922         token_buffer[1].dval  = yylval        = lexer->tokenValue();
2923         token_buffer[1].spell = yytokenspell  = lexer->tokenSpell();
2924         token_buffer[1].loc   = yylloc        = location(lexer);
2925
2926         if (t_action(errorState, yytoken)) {
2927             QString msg;
2928             int token = token_buffer[0].token;
2929             if (token < 0 || token >= TERMINAL_COUNT)
2930                 msg = qApp->translate("QDeclarativeParser", "Syntax error");
2931             else
2932                 msg = qApp->translate("QDeclarativeParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
2933             diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2934
2935             action = errorState;
2936             goto _Lcheck_token;
2937         }
2938
2939         static int tokens[] = {
2940             T_PLUS,
2941             T_EQ,
2942
2943             T_COMMA,
2944             T_COLON,
2945             T_SEMICOLON,
2946
2947             T_RPAREN, T_RBRACKET, T_RBRACE,
2948
2949             T_NUMERIC_LITERAL,
2950             T_IDENTIFIER,
2951
2952             T_LPAREN, T_LBRACKET, T_LBRACE,
2953
2954             EOF_SYMBOL
2955         };
2956
2957         for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
2958             int a = t_action(errorState, *tk);
2959             if (a > 0 && t_action(a, yytoken)) {
2960                 const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
2961                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2962
2963                 yytoken = *tk;
2964                 yylval = 0;
2965                 yylloc = token_buffer[0].loc;
2966                 yylloc.length = 0;
2967
2968                 first_token = &token_buffer[0];
2969                 last_token = &token_buffer[2];
2970
2971                 action = errorState;
2972                 goto _Lcheck_token;
2973             }
2974         }
2975
2976         for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
2977             if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
2978                 tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION ||
2979                 tk == T_FEED_JS_SOURCE_ELEMENT)
2980                continue;
2981
2982             int a = t_action(errorState, tk);
2983             if (a > 0 && t_action(a, yytoken)) {
2984                 const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
2985                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2986
2987                 yytoken = tk;
2988                 yylval = 0;
2989                 yylloc = token_buffer[0].loc;
2990                 yylloc.length = 0;
2991
2992                 action = errorState;
2993                 goto _Lcheck_token;
2994             }
2995         }
2996
2997         const QString msg = qApp->translate("QDeclarativeParser", "Syntax error");
2998         diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2999     }
3000
3001     return false;
3002 }
3003
3004 QT_QML_END_NAMESPACE
3005
3006
3007 ./
3008 /:
3009 QT_QML_END_NAMESPACE
3010
3011
3012
3013 #endif // QDECLARATIVEJSPARSER_P_H
3014 :/