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