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