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