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