1 ----------------------------------------------------------------------------
3 -- Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
4 -- Contact: http://www.qt-project.org/
6 -- This file is part of the QtQml module of the Qt Toolkit.
8 -- $QT_BEGIN_LICENSE:LGPL-ONLY$
9 -- GNU Lesser General Public License Usage
10 -- This file may be used under the terms of the GNU Lesser
11 -- General Public License version 2.1 as published by the Free Software
12 -- Foundation and appearing in the file LICENSE.LGPL included in the
13 -- packaging of this file. Please review the following information to
14 -- ensure the GNU Lesser General Public License version 2.1 requirements
15 -- will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 -- If you have questions regarding the use of this file, please contact
18 -- us via http://www.qt-project.org/.
22 ----------------------------------------------------------------------------
25 %decl qqmljsparser_p.h
26 %impl qdeclarativejsparser.cpp
30 %token T_AND "&" T_AND_AND "&&" T_AND_EQ "&="
31 %token T_BREAK "break" T_CASE "case" T_CATCH "catch"
32 %token T_COLON ":" T_COMMA "," T_CONTINUE "continue"
33 %token T_DEFAULT "default" T_DELETE "delete" T_DIVIDE_ "/"
34 %token T_DIVIDE_EQ "/=" T_DO "do" T_DOT "."
35 %token T_ELSE "else" T_EQ "=" T_EQ_EQ "=="
36 %token T_EQ_EQ_EQ "===" T_FINALLY "finally" T_FOR "for"
37 %token T_FUNCTION "function" T_GE ">=" T_GT ">"
38 %token T_GT_GT ">>" T_GT_GT_EQ ">>=" T_GT_GT_GT ">>>"
39 %token T_GT_GT_GT_EQ ">>>=" T_IDENTIFIER "identifier" T_IF "if"
40 %token T_IN "in" T_INSTANCEOF "instanceof" T_LBRACE "{"
41 %token T_LBRACKET "[" T_LE "<=" T_LPAREN "("
42 %token T_LT "<" T_LT_LT "<<" T_LT_LT_EQ "<<="
43 %token T_MINUS "-" T_MINUS_EQ "-=" T_MINUS_MINUS "--"
44 %token T_NEW "new" T_NOT "!" T_NOT_EQ "!="
45 %token T_NOT_EQ_EQ "!==" T_NUMERIC_LITERAL "numeric literal" T_OR "|"
46 %token T_OR_EQ "|=" T_OR_OR "||" T_PLUS "+"
47 %token T_PLUS_EQ "+=" T_PLUS_PLUS "++" T_QUESTION "?"
48 %token T_RBRACE "}" T_RBRACKET "]" T_REMAINDER "%"
49 %token T_REMAINDER_EQ "%=" T_RETURN "return" T_RPAREN ")"
50 %token T_SEMICOLON ";" T_AUTOMATIC_SEMICOLON T_STAR "*"
51 %token T_STAR_EQ "*=" T_STRING_LITERAL "string literal"
52 %token T_PROPERTY "property" T_SIGNAL "signal" T_READONLY "readonly"
53 %token T_SWITCH "switch" T_THIS "this" T_THROW "throw"
54 %token T_TILDE "~" T_TRY "try" T_TYPEOF "typeof"
55 %token T_VAR "var" T_VOID "void" T_WHILE "while"
56 %token T_WITH "with" T_XOR "^" T_XOR_EQ "^="
57 %token T_NULL "null" T_TRUE "true" T_FALSE "false"
58 %token T_CONST "const"
59 %token T_DEBUGGER "debugger"
60 %token T_RESERVED_WORD "reserved word"
61 %token T_MULTILINE_STRING_LITERAL "multiline string literal"
62 %token T_COMMENT "comment"
65 %token T_PUBLIC "public"
66 %token T_IMPORT "import"
73 %token T_FEED_UI_PROGRAM
74 %token T_FEED_UI_OBJECT_MEMBER
75 %token T_FEED_JS_STATEMENT
76 %token T_FEED_JS_EXPRESSION
77 %token T_FEED_JS_SOURCE_ELEMENT
78 %token T_FEED_JS_PROGRAM
81 %nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY
86 /./****************************************************************************
88 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
89 ** Contact: http://www.qt-project.org/
91 ** This file is part of the QtQml module of the Qt Toolkit.
93 ** $QT_BEGIN_LICENSE:LGPL$
94 ** GNU Lesser General Public License Usage
95 ** This file may be used under the terms of the GNU Lesser General Public
96 ** License version 2.1 as published by the Free Software Foundation and
97 ** appearing in the file LICENSE.LGPL included in the packaging of this
98 ** file. Please review the following information to ensure the GNU Lesser
99 ** General Public License version 2.1 requirements will be met:
100 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
102 ** In addition, as a special exception, Nokia gives you certain additional
103 ** rights. These rights are described in the Nokia Qt LGPL Exception
104 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
106 ** GNU General Public License Usage
107 ** Alternatively, this file may be used under the terms of the GNU General
108 ** Public License version 3.0 as published by the Free Software Foundation
109 ** and appearing in the file LICENSE.GPL included in the packaging of this
110 ** file. Please review the following information to ensure the GNU General
111 ** Public License version 3.0 requirements will be met:
112 ** http://www.gnu.org/copyleft/gpl.html.
115 ** Alternatively, this file may be used in accordance with the terms and
116 ** conditions contained in a signed written agreement between you and Nokia.
125 ****************************************************************************/
127 #include <QtCore/QtDebug>
128 #include <QtCore/QCoreApplication>
132 #include "qqmljsengine_p.h"
133 #include "qqmljslexer_p.h"
134 #include "qqmljsast_p.h"
135 #include "qqmljsmemorypool_p.h"
139 /:/****************************************************************************
141 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
142 ** Contact: http://www.qt-project.org/
144 ** This file is part of the QtQml module of the Qt Toolkit.
146 ** $QT_BEGIN_LICENSE:LGPL$
147 ** GNU Lesser General Public License Usage
148 ** This file may be used under the terms of the GNU Lesser General Public
149 ** License version 2.1 as published by the Free Software Foundation and
150 ** appearing in the file LICENSE.LGPL included in the packaging of this
151 ** file. Please review the following information to ensure the GNU Lesser
152 ** General Public License version 2.1 requirements will be met:
153 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
155 ** In addition, as a special exception, Nokia gives you certain additional
156 ** rights. These rights are described in the Nokia Qt LGPL Exception
157 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
159 ** GNU General Public License Usage
160 ** Alternatively, this file may be used under the terms of the GNU General
161 ** Public License version 3.0 as published by the Free Software Foundation
162 ** and appearing in the file LICENSE.GPL included in the packaging of this
163 ** file. Please review the following information to ensure the GNU General
164 ** Public License version 3.0 requirements will be met:
165 ** http://www.gnu.org/copyleft/gpl.html.
168 ** Alternatively, this file may be used in accordance with the terms and
169 ** conditions contained in a signed written agreement between you and Nokia.
178 ****************************************************************************/
185 // This file is not part of the Qt API. It exists purely as an
186 // implementation detail. This header file may change from version to
187 // version without notice, or even be removed.
193 // This file is automatically generated from qmljs.g.
194 // Changes will be lost.
197 #ifndef QDECLARATIVEJSPARSER_P_H
198 #define QDECLARATIVEJSPARSER_P_H
200 #include "qqmljsglobal_p.h"
201 #include "qqmljsgrammar_p.h"
202 #include "qqmljsast_p.h"
203 #include "qqmljsengine_p.h"
205 #include <QtCore/QList>
206 #include <QtCore/QString>
208 QT_QML_BEGIN_NAMESPACE
214 class QML_PARSER_EXPORT Parser: protected $table
220 AST::ArgumentList *ArgumentList;
221 AST::CaseBlock *CaseBlock;
222 AST::CaseClause *CaseClause;
223 AST::CaseClauses *CaseClauses;
225 AST::DefaultClause *DefaultClause;
226 AST::ElementList *ElementList;
227 AST::Elision *Elision;
228 AST::ExpressionNode *Expression;
229 AST::Finally *Finally;
230 AST::FormalParameterList *FormalParameterList;
231 AST::FunctionBody *FunctionBody;
232 AST::FunctionDeclaration *FunctionDeclaration;
234 AST::PropertyName *PropertyName;
235 AST::PropertyNameAndValueList *PropertyNameAndValueList;
236 AST::SourceElement *SourceElement;
237 AST::SourceElements *SourceElements;
238 AST::Statement *Statement;
239 AST::StatementList *StatementList;
241 AST::VariableDeclaration *VariableDeclaration;
242 AST::VariableDeclarationList *VariableDeclarationList;
244 AST::UiProgram *UiProgram;
245 AST::UiImportList *UiImportList;
246 AST::UiImport *UiImport;
247 AST::UiParameterList *UiParameterList;
248 AST::UiPublicMember *UiPublicMember;
249 AST::UiObjectDefinition *UiObjectDefinition;
250 AST::UiObjectInitializer *UiObjectInitializer;
251 AST::UiObjectBinding *UiObjectBinding;
252 AST::UiScriptBinding *UiScriptBinding;
253 AST::UiArrayBinding *UiArrayBinding;
254 AST::UiObjectMember *UiObjectMember;
255 AST::UiObjectMemberList *UiObjectMemberList;
256 AST::UiArrayMemberList *UiArrayMemberList;
257 AST::UiQualifiedId *UiQualifiedId;
261 Parser(Engine *engine);
264 // parse a UI program
265 bool parse() { return parse(T_FEED_UI_PROGRAM); }
266 bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }
267 bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }
268 bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); }
269 bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); }
270 bool parseProgram() { return parse(T_FEED_JS_PROGRAM); }
272 AST::UiProgram *ast() const
273 { return AST::cast<AST::UiProgram *>(program); }
275 AST::Statement *statement() const
280 return program->statementCast();
283 AST::ExpressionNode *expression() const
288 return program->expressionCast();
291 AST::UiObjectMember *uiObjectMember() const
296 return program->uiObjectMemberCast();
299 AST::Node *rootNode() const
302 QList<DiagnosticMessage> diagnosticMessages() const
303 { return diagnostic_messages; }
305 inline DiagnosticMessage diagnosticMessage() const
307 foreach (const DiagnosticMessage &d, diagnostic_messages) {
308 if (! d.kind == DiagnosticMessage::Warning)
312 return DiagnosticMessage();
315 inline QString errorMessage() const
316 { return diagnosticMessage().message; }
318 inline int errorLineNumber() const
319 { return diagnosticMessage().loc.startLine; }
321 inline int errorColumnNumber() const
322 { return diagnosticMessage().loc.startColumn; }
325 bool parse(int startToken);
327 void reallocateStack();
329 inline Value &sym(int index)
330 { return sym_stack [tos + index - 1]; }
332 inline QStringRef &stringRef(int index)
333 { return string_stack [tos + index - 1]; }
335 inline AST::SourceLocation &loc(int index)
336 { return location_stack [tos + index - 1]; }
338 AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);
347 AST::SourceLocation *location_stack;
348 QStringRef *string_stack;
353 enum { TOKEN_BUFFER_SIZE = 3 };
358 AST::SourceLocation loc;
363 QStringRef yytokenspell;
364 AST::SourceLocation yylloc;
365 AST::SourceLocation yyprevlloc;
367 SavedToken token_buffer[TOKEN_BUFFER_SIZE];
368 SavedToken *first_token;
369 SavedToken *last_token;
371 QList<DiagnosticMessage> diagnostic_messages;
374 } // end of namespace QQmlJS
382 #include "qqmljsparser_p.h"
383 #include <QVarLengthArray>
386 // This file is automatically generated from qmljs.g.
387 // Changes will be lost.
390 using namespace QQmlJS;
392 QT_QML_BEGIN_NAMESPACE
394 void Parser::reallocateStack()
401 sym_stack = reinterpret_cast<Value*> (realloc(sym_stack, stack_size * sizeof(Value)));
402 state_stack = reinterpret_cast<int*> (realloc(state_stack, stack_size * sizeof(int)));
403 location_stack = reinterpret_cast<AST::SourceLocation*> (realloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
404 string_stack = reinterpret_cast<QStringRef*> (realloc(string_stack, stack_size * sizeof(QStringRef)));
407 Parser::Parser(Engine *engine):
409 pool(engine->pool()),
426 free(location_stack);
431 static inline AST::SourceLocation location(Lexer *lexer)
433 AST::SourceLocation loc;
434 loc.offset = lexer->tokenOffset();
435 loc.length = lexer->tokenLength();
436 loc.startLine = lexer->tokenStartLine();
437 loc.startColumn = lexer->tokenStartColumn();
441 AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
443 QVarLengthArray<QStringRef, 4> nameIds;
444 QVarLengthArray<AST::SourceLocation, 4> locations;
446 AST::ExpressionNode *it = expr;
447 while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
448 nameIds.append(m->name);
449 locations.append(m->identifierToken);
453 if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
454 AST::UiQualifiedId *q = new (pool) AST::UiQualifiedId(idExpr->name);
455 q->identifierToken = idExpr->identifierToken;
457 AST::UiQualifiedId *currentId = q;
458 for (int i = nameIds.size() - 1; i != -1; --i) {
459 currentId = new (pool) AST::UiQualifiedId(currentId, nameIds[i]);
460 currentId->identifierToken = locations[i];
463 return currentId->finish();
469 bool Parser::parse(int startToken)
471 Lexer *lexer = driver->lexer();
472 bool hadErrors = false;
476 token_buffer[0].token = startToken;
477 first_token = &token_buffer[0];
478 last_token = &token_buffer[1];
484 if (++tos == stack_size)
487 state_stack[tos] = action;
490 if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
493 if (first_token == last_token) {
494 yytoken = lexer->lex();
495 yylval = lexer->tokenValue();
496 yytokenspell = lexer->tokenSpell();
497 yylloc = location(lexer);
499 yytoken = first_token->token;
500 yylval = first_token->dval;
501 yytokenspell = first_token->spell;
502 yylloc = first_token->loc;
507 action = t_action(action, yytoken);
509 if (action != ACCEPT_STATE) {
511 sym(1).dval = yylval;
512 stringRef(1) = yytokenspell;
518 } else if (action < 0) {
519 const int r = -action - 1;
525 --------------------------------------------------------------------------------------------------------
527 --------------------------------------------------------------------------------------------------------
529 TopLevel: T_FEED_UI_PROGRAM UiProgram ;
532 sym(1).Node = sym(2).Node;
533 program = sym(1).Node;
537 TopLevel: T_FEED_JS_STATEMENT Statement ;
540 sym(1).Node = sym(2).Node;
541 program = sym(1).Node;
545 TopLevel: T_FEED_JS_EXPRESSION Expression ;
548 sym(1).Node = sym(2).Node;
549 program = sym(1).Node;
553 TopLevel: T_FEED_JS_SOURCE_ELEMENT SourceElement ;
556 sym(1).Node = sym(2).Node;
557 program = sym(1).Node;
561 TopLevel: T_FEED_UI_OBJECT_MEMBER UiObjectMember ;
564 sym(1).Node = sym(2).Node;
565 program = sym(1).Node;
569 TopLevel: T_FEED_JS_PROGRAM Program ;
572 sym(1).Node = sym(2).Node;
573 program = sym(1).Node;
577 UiProgram: UiImportListOpt UiRootMember ;
580 sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiImportList,
581 sym(2).UiObjectMemberList->finish());
585 UiImportListOpt: Empty ;
586 UiImportListOpt: UiImportList ;
589 sym(1).Node = sym(1).UiImportList->finish();
593 UiImportList: UiImport ;
596 sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImport);
600 UiImportList: UiImportList UiImport ;
603 sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImportList, sym(2).UiImport);
607 ImportId: MemberExpression ;
609 UiImport: UiImportHead T_AUTOMATIC_SEMICOLON ;
610 UiImport: UiImportHead T_SEMICOLON ;
613 sym(1).UiImport->semicolonToken = loc(2);
617 UiImport: UiImportHead T_NUMERIC_LITERAL T_AUTOMATIC_SEMICOLON ;
618 UiImport: UiImportHead T_NUMERIC_LITERAL T_SEMICOLON ;
621 sym(1).UiImport->versionToken = loc(2);
622 sym(1).UiImport->semicolonToken = loc(3);
626 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
627 UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_SEMICOLON ;
630 sym(1).UiImport->versionToken = loc(2);
631 sym(1).UiImport->asToken = loc(3);
632 sym(1).UiImport->importIdToken = loc(4);
633 sym(1).UiImport->importId = stringRef(4);
634 sym(1).UiImport->semicolonToken = loc(5);
638 UiImport: UiImportHead T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
639 UiImport: UiImportHead T_AS JsIdentifier T_SEMICOLON ;
642 sym(1).UiImport->asToken = loc(2);
643 sym(1).UiImport->importIdToken = loc(3);
644 sym(1).UiImport->importId = stringRef(3);
645 sym(1).UiImport->semicolonToken = loc(4);
650 UiImportHead: T_IMPORT ImportId ;
653 AST::UiImport *node = 0;
655 if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
656 node = new (pool) AST::UiImport(importIdLiteral->value);
657 node->fileNameToken = loc(2);
658 } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
659 node = new (pool) AST::UiImport(qualifiedId);
660 node->fileNameToken = loc(2);
666 node->importToken = loc(1);
668 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
669 QLatin1String("Expected a qualified name id or a string literal")));
671 return false; // ### remove me
683 UiRootMember: UiObjectDefinition ;
686 sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
690 UiObjectMemberList: UiObjectMember ;
693 sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
697 UiObjectMemberList: UiObjectMemberList UiObjectMember ;
700 AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(
701 sym(1).UiObjectMemberList, sym(2).UiObjectMember);
706 UiArrayMemberList: UiObjectDefinition ;
709 sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
713 UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ;
716 AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(
717 sym(1).UiArrayMemberList, sym(3).UiObjectMember);
718 node->commaToken = loc(2);
723 UiObjectInitializer: T_LBRACE T_RBRACE ;
726 AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
727 node->lbraceToken = loc(1);
728 node->rbraceToken = loc(2);
733 UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ;
736 AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish());
737 node->lbraceToken = loc(1);
738 node->rbraceToken = loc(3);
743 UiObjectDefinition: UiQualifiedId UiObjectInitializer ;
746 AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId,
747 sym(2).UiObjectInitializer);
752 UiObjectMember: UiObjectDefinition ;
754 UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
757 AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(
758 sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
759 node->colonToken = loc(2);
760 node->lbracketToken = loc(3);
761 node->rbracketToken = loc(5);
766 UiObjectMember: UiQualifiedId T_COLON UiQualifiedId UiObjectInitializer ;
769 AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
770 sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
771 node->colonToken = loc(2);
776 UiObjectMember: UiQualifiedId T_ON UiQualifiedId UiObjectInitializer ;
779 AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
780 sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
781 node->colonToken = loc(2);
782 node->hasOnToken = true;
787 UiScriptStatement: Block ;
788 UiScriptStatement: EmptyStatement ;
789 UiScriptStatement: ExpressionStatement ;
790 UiScriptStatement: IfStatement ;
791 UiScriptStatement: WithStatement ;
792 UiScriptStatement: SwitchStatement ;
793 UiScriptStatement: TryStatement ;
795 UiObjectMember: UiQualifiedId T_COLON UiScriptStatement ;
799 AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(
800 sym(1).UiQualifiedId, sym(3).Statement);
801 node->colonToken = loc(2);
806 UiPropertyType: T_VAR ;
807 UiPropertyType: T_RESERVED_WORD ;
808 UiPropertyType: T_IDENTIFIER ;
810 UiParameterListOpt: ;
817 UiParameterListOpt: UiParameterList ;
820 sym(1).Node = sym(1).UiParameterList->finish ();
824 UiParameterList: UiPropertyType JsIdentifier ;
827 AST::UiParameterList *node = new (pool) AST::UiParameterList(stringRef(1), stringRef(2));
828 node->propertyTypeToken = loc(1);
829 node->identifierToken = loc(2);
834 UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ;
837 AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, stringRef(3), stringRef(4));
838 node->commaToken = loc(2);
839 node->identifierToken = loc(4);
844 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_AUTOMATIC_SEMICOLON ;
845 UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ;
848 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
849 node->type = AST::UiPublicMember::Signal;
850 node->propertyToken = loc(1);
851 node->typeToken = loc(2);
852 node->identifierToken = loc(2);
853 node->parameters = sym(4).UiParameterList;
854 node->semicolonToken = loc(6);
859 UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;
860 UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ;
863 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
864 node->type = AST::UiPublicMember::Signal;
865 node->propertyToken = loc(1);
866 node->typeToken = loc(2);
867 node->identifierToken = loc(2);
868 node->semicolonToken = loc(3);
873 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_AUTOMATIC_SEMICOLON ;
874 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ;
877 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
878 node->typeModifier = stringRef(2);
879 node->propertyToken = loc(1);
880 node->typeModifierToken = loc(2);
881 node->typeToken = loc(4);
882 node->identifierToken = loc(6);
883 node->semicolonToken = loc(7);
888 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
889 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
892 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
893 node->propertyToken = loc(1);
894 node->typeToken = loc(2);
895 node->identifierToken = loc(3);
896 node->semicolonToken = loc(4);
901 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
902 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
905 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4));
906 node->isDefaultMember = true;
907 node->defaultToken = loc(1);
908 node->propertyToken = loc(2);
909 node->typeToken = loc(3);
910 node->identifierToken = loc(4);
911 node->semicolonToken = loc(5);
916 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
919 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3),
921 node->propertyToken = loc(1);
922 node->typeToken = loc(2);
923 node->identifierToken = loc(3);
924 node->colonToken = loc(4);
929 UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
932 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
934 node->isReadonlyMember = true;
935 node->readonlyToken = loc(1);
936 node->propertyToken = loc(2);
937 node->typeToken = loc(3);
938 node->identifierToken = loc(4);
939 node->colonToken = loc(5);
944 UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
947 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
949 node->isDefaultMember = true;
950 node->defaultToken = loc(1);
951 node->propertyToken = loc(2);
952 node->typeToken = loc(3);
953 node->identifierToken = loc(4);
954 node->colonToken = loc(5);
959 UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
962 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
963 node->typeModifier = stringRef(2);
964 node->propertyToken = loc(1);
965 node->typeModifierToken = loc(2);
966 node->typeToken = loc(4);
967 node->identifierToken = loc(6);
968 node->semicolonToken = loc(7); // insert a fake ';' before ':'
970 AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(6));
971 propertyName->identifierToken = loc(6);
972 propertyName->next = 0;
974 AST::UiArrayBinding *binding = new (pool) AST::UiArrayBinding(
975 propertyName, sym(9).UiArrayMemberList->finish());
976 binding->colonToken = loc(7);
977 binding->lbracketToken = loc(8);
978 binding->rbracketToken = loc(10);
980 node->binding = binding;
986 UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ;
989 AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
990 node->propertyToken = loc(1);
991 node->typeToken = loc(2);
992 node->identifierToken = loc(3);
993 node->semicolonToken = loc(4); // insert a fake ';' before ':'
995 AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(3));
996 propertyName->identifierToken = loc(3);
997 propertyName->next = 0;
999 AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
1000 propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
1001 binding->colonToken = loc(4);
1003 node->binding = binding;
1009 UiObjectMember: FunctionDeclaration ;
1011 case $rule_number: {
1012 sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
1016 UiObjectMember: VariableStatement ;
1018 case $rule_number: {
1019 sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
1023 JsIdentifier: T_IDENTIFIER;
1025 JsIdentifier: T_PROPERTY ;
1026 JsIdentifier: T_SIGNAL ;
1027 JsIdentifier: T_READONLY ;
1028 JsIdentifier: T_ON ;
1030 --------------------------------------------------------------------------------------------------------
1032 --------------------------------------------------------------------------------------------------------
1034 PrimaryExpression: T_THIS ;
1036 case $rule_number: {
1037 AST::ThisExpression *node = new (pool) AST::ThisExpression();
1038 node->thisToken = loc(1);
1043 PrimaryExpression: JsIdentifier ;
1045 case $rule_number: {
1046 AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
1047 node->identifierToken = loc(1);
1052 PrimaryExpression: T_NULL ;
1054 case $rule_number: {
1055 AST::NullExpression *node = new (pool) AST::NullExpression();
1056 node->nullToken = loc(1);
1061 PrimaryExpression: T_TRUE ;
1063 case $rule_number: {
1064 AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
1065 node->trueToken = loc(1);
1070 PrimaryExpression: T_FALSE ;
1072 case $rule_number: {
1073 AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
1074 node->falseToken = loc(1);
1079 PrimaryExpression: T_NUMERIC_LITERAL ;
1081 case $rule_number: {
1082 AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
1083 node->literalToken = loc(1);
1088 PrimaryExpression: T_MULTILINE_STRING_LITERAL ;
1089 /.case $rule_number:./
1091 PrimaryExpression: T_STRING_LITERAL ;
1093 case $rule_number: {
1094 AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
1095 node->literalToken = loc(1);
1100 PrimaryExpression: T_DIVIDE_ ;
1102 #define J_SCRIPT_REGEXPLITERAL_RULE1 $rule_number
1105 case $rule_number: {
1106 bool rx = lexer->scanRegExp(Lexer::NoPrefix);
1108 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
1109 return false; // ### remove me
1112 loc(1).length = lexer->tokenLength();
1113 yylloc = loc(1); // adjust the location of the current token
1115 AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
1116 driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
1117 node->literalToken = loc(1);
1122 PrimaryExpression: T_DIVIDE_EQ ;
1124 #define J_SCRIPT_REGEXPLITERAL_RULE2 $rule_number
1127 case $rule_number: {
1128 bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
1130 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
1134 loc(1).length = lexer->tokenLength();
1135 yylloc = loc(1); // adjust the location of the current token
1137 AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
1138 driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
1139 node->literalToken = loc(1);
1144 PrimaryExpression: T_LBRACKET T_RBRACKET ;
1146 case $rule_number: {
1147 AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral((AST::Elision *) 0);
1148 node->lbracketToken = loc(1);
1149 node->rbracketToken = loc(2);
1154 PrimaryExpression: T_LBRACKET Elision T_RBRACKET ;
1156 case $rule_number: {
1157 AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).Elision->finish());
1158 node->lbracketToken = loc(1);
1159 node->rbracketToken = loc(3);
1164 PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ;
1166 case $rule_number: {
1167 AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish ());
1168 node->lbracketToken = loc(1);
1169 node->rbracketToken = loc(3);
1174 PrimaryExpression: T_LBRACKET ElementList T_COMMA T_RBRACKET ;
1176 case $rule_number: {
1177 AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
1178 (AST::Elision *) 0);
1179 node->lbracketToken = loc(1);
1180 node->commaToken = loc(3);
1181 node->rbracketToken = loc(4);
1186 PrimaryExpression: T_LBRACKET ElementList T_COMMA Elision T_RBRACKET ;
1188 case $rule_number: {
1189 AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
1190 sym(4).Elision->finish());
1191 node->lbracketToken = loc(1);
1192 node->commaToken = loc(3);
1193 node->rbracketToken = loc(5);
1198 -- PrimaryExpression: T_LBRACE T_RBRACE ;
1200 -- case $rule_number: {
1201 -- sym(1).Node = new (pool) AST::ObjectLiteral();
1205 PrimaryExpression: T_LBRACE PropertyNameAndValueListOpt T_RBRACE ;
1207 case $rule_number: {
1208 AST::ObjectLiteral *node = 0;
1210 node = new (pool) AST::ObjectLiteral(
1211 sym(2).PropertyNameAndValueList->finish ());
1213 node = new (pool) AST::ObjectLiteral();
1214 node->lbraceToken = loc(1);
1215 node->rbraceToken = loc(3);
1220 PrimaryExpression: T_LBRACE PropertyNameAndValueList T_COMMA T_RBRACE ;
1222 case $rule_number: {
1223 AST::ObjectLiteral *node = new (pool) AST::ObjectLiteral(
1224 sym(2).PropertyNameAndValueList->finish ());
1225 node->lbraceToken = loc(1);
1226 node->rbraceToken = loc(4);
1231 PrimaryExpression: T_LPAREN Expression T_RPAREN ;
1233 case $rule_number: {
1234 AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression);
1235 node->lparenToken = loc(1);
1236 node->rparenToken = loc(3);
1241 UiQualifiedId: MemberExpression ;
1243 case $rule_number: {
1244 if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
1245 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken,
1246 QLatin1String("Ignored annotation")));
1248 sym(1).Expression = mem->base;
1251 if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
1252 sym(1).UiQualifiedId = qualifiedId;
1254 sym(1).UiQualifiedId = 0;
1256 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
1257 QLatin1String("Expected a qualified name id")));
1259 return false; // ### recover
1264 ElementList: AssignmentExpression ;
1266 case $rule_number: {
1267 sym(1).Node = new (pool) AST::ElementList((AST::Elision *) 0, sym(1).Expression);
1271 ElementList: Elision AssignmentExpression ;
1273 case $rule_number: {
1274 sym(1).Node = new (pool) AST::ElementList(sym(1).Elision->finish(), sym(2).Expression);
1278 ElementList: ElementList T_COMMA AssignmentExpression ;
1280 case $rule_number: {
1281 AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList,
1282 (AST::Elision *) 0, sym(3).Expression);
1283 node->commaToken = loc(2);
1288 ElementList: ElementList T_COMMA Elision AssignmentExpression ;
1290 case $rule_number: {
1291 AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList, sym(3).Elision->finish(),
1293 node->commaToken = loc(2);
1300 case $rule_number: {
1301 AST::Elision *node = new (pool) AST::Elision();
1302 node->commaToken = loc(1);
1307 Elision: Elision T_COMMA ;
1309 case $rule_number: {
1310 AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
1311 node->commaToken = loc(2);
1316 PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ;
1318 case $rule_number: {
1319 AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
1320 sym(1).PropertyName, sym(3).Expression);
1321 node->colonToken = loc(2);
1326 PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ;
1328 case $rule_number: {
1329 AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
1330 sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
1331 node->commaToken = loc(2);
1332 node->colonToken = loc(4);
1337 PropertyName: T_IDENTIFIER %prec SHIFT_THERE ;
1339 case $rule_number: {
1340 AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
1341 node->propertyNameToken = loc(1);
1346 PropertyName: T_SIGNAL ;
1347 /.case $rule_number:./
1349 PropertyName: T_PROPERTY ;
1351 case $rule_number: {
1352 AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
1353 node->propertyNameToken = loc(1);
1358 PropertyName: T_STRING_LITERAL ;
1360 case $rule_number: {
1361 AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
1362 node->propertyNameToken = loc(1);
1367 PropertyName: T_NUMERIC_LITERAL ;
1369 case $rule_number: {
1370 AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
1371 node->propertyNameToken = loc(1);
1376 PropertyName: ReservedIdentifier ;
1378 case $rule_number: {
1379 AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
1380 node->propertyNameToken = loc(1);
1385 ReservedIdentifier: T_BREAK ;
1386 ReservedIdentifier: T_CASE ;
1387 ReservedIdentifier: T_CATCH ;
1388 ReservedIdentifier: T_CONTINUE ;
1389 ReservedIdentifier: T_DEFAULT ;
1390 ReservedIdentifier: T_DELETE ;
1391 ReservedIdentifier: T_DO ;
1392 ReservedIdentifier: T_ELSE ;
1393 ReservedIdentifier: T_FALSE ;
1394 ReservedIdentifier: T_FINALLY ;
1395 ReservedIdentifier: T_FOR ;
1396 ReservedIdentifier: T_FUNCTION ;
1397 ReservedIdentifier: T_IF ;
1398 ReservedIdentifier: T_IN ;
1399 ReservedIdentifier: T_INSTANCEOF ;
1400 ReservedIdentifier: T_NEW ;
1401 ReservedIdentifier: T_NULL ;
1402 ReservedIdentifier: T_RETURN ;
1403 ReservedIdentifier: T_SWITCH ;
1404 ReservedIdentifier: T_THIS ;
1405 ReservedIdentifier: T_THROW ;
1406 ReservedIdentifier: T_TRUE ;
1407 ReservedIdentifier: T_TRY ;
1408 ReservedIdentifier: T_TYPEOF ;
1409 ReservedIdentifier: T_VAR ;
1410 ReservedIdentifier: T_VOID ;
1411 ReservedIdentifier: T_WHILE ;
1412 ReservedIdentifier: T_CONST ;
1413 ReservedIdentifier: T_DEBUGGER ;
1414 ReservedIdentifier: T_RESERVED_WORD ;
1415 ReservedIdentifier: T_WITH ;
1417 PropertyIdentifier: JsIdentifier ;
1418 PropertyIdentifier: ReservedIdentifier ;
1420 MemberExpression: PrimaryExpression ;
1421 MemberExpression: FunctionExpression ;
1423 MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ;
1425 case $rule_number: {
1426 AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
1427 node->lbracketToken = loc(2);
1428 node->rbracketToken = loc(4);
1433 MemberExpression: MemberExpression T_DOT PropertyIdentifier ;
1435 case $rule_number: {
1436 AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
1437 node->dotToken = loc(2);
1438 node->identifierToken = loc(3);
1443 MemberExpression: T_NEW MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
1445 case $rule_number: {
1446 AST::NewMemberExpression *node = new (pool) AST::NewMemberExpression(sym(2).Expression, sym(4).ArgumentList);
1447 node->newToken = loc(1);
1448 node->lparenToken = loc(3);
1449 node->rparenToken = loc(5);
1454 NewExpression: MemberExpression ;
1456 NewExpression: T_NEW NewExpression ;
1458 case $rule_number: {
1459 AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
1460 node->newToken = loc(1);
1465 CallExpression: MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
1467 case $rule_number: {
1468 AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
1469 node->lparenToken = loc(2);
1470 node->rparenToken = loc(4);
1475 CallExpression: CallExpression T_LPAREN ArgumentListOpt T_RPAREN ;
1477 case $rule_number: {
1478 AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
1479 node->lparenToken = loc(2);
1480 node->rparenToken = loc(4);
1485 CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ;
1487 case $rule_number: {
1488 AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
1489 node->lbracketToken = loc(2);
1490 node->rbracketToken = loc(4);
1495 CallExpression: CallExpression T_DOT PropertyIdentifier ;
1497 case $rule_number: {
1498 AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
1499 node->dotToken = loc(2);
1500 node->identifierToken = loc(3);
1507 case $rule_number: {
1512 ArgumentListOpt: ArgumentList ;
1514 case $rule_number: {
1515 sym(1).Node = sym(1).ArgumentList->finish();
1519 ArgumentList: AssignmentExpression ;
1521 case $rule_number: {
1522 sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
1526 ArgumentList: ArgumentList T_COMMA AssignmentExpression ;
1528 case $rule_number: {
1529 AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
1530 node->commaToken = loc(2);
1535 LeftHandSideExpression: NewExpression ;
1536 LeftHandSideExpression: CallExpression ;
1537 PostfixExpression: LeftHandSideExpression ;
1539 PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ;
1541 case $rule_number: {
1542 AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
1543 node->incrementToken = loc(2);
1548 PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ;
1550 case $rule_number: {
1551 AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
1552 node->decrementToken = loc(2);
1557 UnaryExpression: PostfixExpression ;
1559 UnaryExpression: T_DELETE UnaryExpression ;
1561 case $rule_number: {
1562 AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
1563 node->deleteToken = loc(1);
1568 UnaryExpression: T_VOID UnaryExpression ;
1570 case $rule_number: {
1571 AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
1572 node->voidToken = loc(1);
1577 UnaryExpression: T_TYPEOF UnaryExpression ;
1579 case $rule_number: {
1580 AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
1581 node->typeofToken = loc(1);
1586 UnaryExpression: T_PLUS_PLUS UnaryExpression ;
1588 case $rule_number: {
1589 AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
1590 node->incrementToken = loc(1);
1595 UnaryExpression: T_MINUS_MINUS UnaryExpression ;
1597 case $rule_number: {
1598 AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
1599 node->decrementToken = loc(1);
1604 UnaryExpression: T_PLUS UnaryExpression ;
1606 case $rule_number: {
1607 AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
1608 node->plusToken = loc(1);
1613 UnaryExpression: T_MINUS UnaryExpression ;
1615 case $rule_number: {
1616 AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
1617 node->minusToken = loc(1);
1622 UnaryExpression: T_TILDE UnaryExpression ;
1624 case $rule_number: {
1625 AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
1626 node->tildeToken = loc(1);
1631 UnaryExpression: T_NOT UnaryExpression ;
1633 case $rule_number: {
1634 AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
1635 node->notToken = loc(1);
1640 MultiplicativeExpression: UnaryExpression ;
1642 MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ;
1644 case $rule_number: {
1645 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1646 QSOperator::Mul, sym(3).Expression);
1647 node->operatorToken = loc(2);
1652 MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ;
1654 case $rule_number: {
1655 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1656 QSOperator::Div, sym(3).Expression);
1657 node->operatorToken = loc(2);
1662 MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ;
1664 case $rule_number: {
1665 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1666 QSOperator::Mod, sym(3).Expression);
1667 node->operatorToken = loc(2);
1672 AdditiveExpression: MultiplicativeExpression ;
1674 AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ;
1676 case $rule_number: {
1677 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1678 QSOperator::Add, sym(3).Expression);
1679 node->operatorToken = loc(2);
1684 AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ;
1686 case $rule_number: {
1687 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1688 QSOperator::Sub, sym(3).Expression);
1689 node->operatorToken = loc(2);
1694 ShiftExpression: AdditiveExpression ;
1696 ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ;
1698 case $rule_number: {
1699 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1700 QSOperator::LShift, sym(3).Expression);
1701 node->operatorToken = loc(2);
1706 ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ;
1708 case $rule_number: {
1709 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1710 QSOperator::RShift, sym(3).Expression);
1711 node->operatorToken = loc(2);
1716 ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ;
1718 case $rule_number: {
1719 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1720 QSOperator::URShift, sym(3).Expression);
1721 node->operatorToken = loc(2);
1726 RelationalExpression: ShiftExpression ;
1728 RelationalExpression: RelationalExpression T_LT ShiftExpression ;
1730 case $rule_number: {
1731 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1732 QSOperator::Lt, sym(3).Expression);
1733 node->operatorToken = loc(2);
1738 RelationalExpression: RelationalExpression T_GT ShiftExpression ;
1740 case $rule_number: {
1741 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1742 QSOperator::Gt, sym(3).Expression);
1743 node->operatorToken = loc(2);
1748 RelationalExpression: RelationalExpression T_LE ShiftExpression ;
1750 case $rule_number: {
1751 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1752 QSOperator::Le, sym(3).Expression);
1753 node->operatorToken = loc(2);
1758 RelationalExpression: RelationalExpression T_GE ShiftExpression ;
1760 case $rule_number: {
1761 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1762 QSOperator::Ge, sym(3).Expression);
1763 node->operatorToken = loc(2);
1768 RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ;
1770 case $rule_number: {
1771 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1772 QSOperator::InstanceOf, sym(3).Expression);
1773 node->operatorToken = loc(2);
1778 RelationalExpression: RelationalExpression T_IN ShiftExpression ;
1780 case $rule_number: {
1781 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1782 QSOperator::In, sym(3).Expression);
1783 node->operatorToken = loc(2);
1788 RelationalExpressionNotIn: ShiftExpression ;
1790 RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ;
1792 case $rule_number: {
1793 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1794 QSOperator::Lt, sym(3).Expression);
1795 node->operatorToken = loc(2);
1800 RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ;
1802 case $rule_number: {
1803 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1804 QSOperator::Gt, sym(3).Expression);
1805 node->operatorToken = loc(2);
1810 RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ;
1812 case $rule_number: {
1813 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1814 QSOperator::Le, sym(3).Expression);
1815 node->operatorToken = loc(2);
1820 RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ;
1822 case $rule_number: {
1823 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1824 QSOperator::Ge, sym(3).Expression);
1825 node->operatorToken = loc(2);
1830 RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ;
1832 case $rule_number: {
1833 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1834 QSOperator::InstanceOf, sym(3).Expression);
1835 node->operatorToken = loc(2);
1840 EqualityExpression: RelationalExpression ;
1842 EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ;
1844 case $rule_number: {
1845 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1846 QSOperator::Equal, sym(3).Expression);
1847 node->operatorToken = loc(2);
1852 EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ;
1854 case $rule_number: {
1855 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1856 QSOperator::NotEqual, sym(3).Expression);
1857 node->operatorToken = loc(2);
1862 EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ;
1864 case $rule_number: {
1865 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1866 QSOperator::StrictEqual, sym(3).Expression);
1867 node->operatorToken = loc(2);
1872 EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ;
1874 case $rule_number: {
1875 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1876 QSOperator::StrictNotEqual, sym(3).Expression);
1877 node->operatorToken = loc(2);
1882 EqualityExpressionNotIn: RelationalExpressionNotIn ;
1884 EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ;
1886 case $rule_number: {
1887 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1888 QSOperator::Equal, sym(3).Expression);
1889 node->operatorToken = loc(2);
1894 EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn;
1896 case $rule_number: {
1897 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1898 QSOperator::NotEqual, sym(3).Expression);
1899 node->operatorToken = loc(2);
1904 EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ;
1906 case $rule_number: {
1907 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1908 QSOperator::StrictEqual, sym(3).Expression);
1909 node->operatorToken = loc(2);
1914 EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ;
1916 case $rule_number: {
1917 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1918 QSOperator::StrictNotEqual, sym(3).Expression);
1919 node->operatorToken = loc(2);
1924 BitwiseANDExpression: EqualityExpression ;
1926 BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ;
1928 case $rule_number: {
1929 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1930 QSOperator::BitAnd, sym(3).Expression);
1931 node->operatorToken = loc(2);
1936 BitwiseANDExpressionNotIn: EqualityExpressionNotIn ;
1938 BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ;
1940 case $rule_number: {
1941 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1942 QSOperator::BitAnd, sym(3).Expression);
1943 node->operatorToken = loc(2);
1948 BitwiseXORExpression: BitwiseANDExpression ;
1950 BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ;
1952 case $rule_number: {
1953 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1954 QSOperator::BitXor, sym(3).Expression);
1955 node->operatorToken = loc(2);
1960 BitwiseXORExpressionNotIn: BitwiseANDExpressionNotIn ;
1962 BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ;
1964 case $rule_number: {
1965 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1966 QSOperator::BitXor, sym(3).Expression);
1967 node->operatorToken = loc(2);
1972 BitwiseORExpression: BitwiseXORExpression ;
1974 BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ;
1976 case $rule_number: {
1977 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1978 QSOperator::BitOr, sym(3).Expression);
1979 node->operatorToken = loc(2);
1984 BitwiseORExpressionNotIn: BitwiseXORExpressionNotIn ;
1986 BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ;
1988 case $rule_number: {
1989 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1990 QSOperator::BitOr, sym(3).Expression);
1991 node->operatorToken = loc(2);
1996 LogicalANDExpression: BitwiseORExpression ;
1998 LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ;
2000 case $rule_number: {
2001 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
2002 QSOperator::And, sym(3).Expression);
2003 node->operatorToken = loc(2);
2008 LogicalANDExpressionNotIn: BitwiseORExpressionNotIn ;
2010 LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ;
2012 case $rule_number: {
2013 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
2014 QSOperator::And, sym(3).Expression);
2015 node->operatorToken = loc(2);
2020 LogicalORExpression: LogicalANDExpression ;
2022 LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ;
2024 case $rule_number: {
2025 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
2026 QSOperator::Or, sym(3).Expression);
2027 node->operatorToken = loc(2);
2032 LogicalORExpressionNotIn: LogicalANDExpressionNotIn ;
2034 LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ;
2036 case $rule_number: {
2037 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
2038 QSOperator::Or, sym(3).Expression);
2039 node->operatorToken = loc(2);
2044 ConditionalExpression: LogicalORExpression ;
2046 ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ;
2048 case $rule_number: {
2049 AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
2050 sym(3).Expression, sym(5).Expression);
2051 node->questionToken = loc(2);
2052 node->colonToken = loc(4);
2057 ConditionalExpressionNotIn: LogicalORExpressionNotIn ;
2059 ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ;
2061 case $rule_number: {
2062 AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
2063 sym(3).Expression, sym(5).Expression);
2064 node->questionToken = loc(2);
2065 node->colonToken = loc(4);
2070 AssignmentExpression: ConditionalExpression ;
2072 AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ;
2074 case $rule_number: {
2075 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
2076 sym(2).ival, sym(3).Expression);
2077 node->operatorToken = loc(2);
2082 AssignmentExpressionNotIn: ConditionalExpressionNotIn ;
2084 AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ;
2086 case $rule_number: {
2087 AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
2088 sym(2).ival, sym(3).Expression);
2089 node->operatorToken = loc(2);
2094 AssignmentOperator: T_EQ ;
2096 case $rule_number: {
2097 sym(1).ival = QSOperator::Assign;
2101 AssignmentOperator: T_STAR_EQ ;
2103 case $rule_number: {
2104 sym(1).ival = QSOperator::InplaceMul;
2108 AssignmentOperator: T_DIVIDE_EQ ;
2110 case $rule_number: {
2111 sym(1).ival = QSOperator::InplaceDiv;
2115 AssignmentOperator: T_REMAINDER_EQ ;
2117 case $rule_number: {
2118 sym(1).ival = QSOperator::InplaceMod;
2122 AssignmentOperator: T_PLUS_EQ ;
2124 case $rule_number: {
2125 sym(1).ival = QSOperator::InplaceAdd;
2129 AssignmentOperator: T_MINUS_EQ ;
2131 case $rule_number: {
2132 sym(1).ival = QSOperator::InplaceSub;
2136 AssignmentOperator: T_LT_LT_EQ ;
2138 case $rule_number: {
2139 sym(1).ival = QSOperator::InplaceLeftShift;
2143 AssignmentOperator: T_GT_GT_EQ ;
2145 case $rule_number: {
2146 sym(1).ival = QSOperator::InplaceRightShift;
2150 AssignmentOperator: T_GT_GT_GT_EQ ;
2152 case $rule_number: {
2153 sym(1).ival = QSOperator::InplaceURightShift;
2157 AssignmentOperator: T_AND_EQ ;
2159 case $rule_number: {
2160 sym(1).ival = QSOperator::InplaceAnd;
2164 AssignmentOperator: T_XOR_EQ ;
2166 case $rule_number: {
2167 sym(1).ival = QSOperator::InplaceXor;
2171 AssignmentOperator: T_OR_EQ ;
2173 case $rule_number: {
2174 sym(1).ival = QSOperator::InplaceOr;
2178 Expression: AssignmentExpression ;
2180 Expression: Expression T_COMMA AssignmentExpression ;
2182 case $rule_number: {
2183 AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
2184 node->commaToken = loc(2);
2191 case $rule_number: {
2196 ExpressionOpt: Expression ;
2198 ExpressionNotIn: AssignmentExpressionNotIn ;
2200 ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ;
2202 case $rule_number: {
2203 AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
2204 node->commaToken = loc(2);
2209 ExpressionNotInOpt: ;
2211 case $rule_number: {
2216 ExpressionNotInOpt: ExpressionNotIn ;
2219 Statement: VariableStatement ;
2220 Statement: EmptyStatement ;
2221 Statement: ExpressionStatement ;
2222 Statement: IfStatement ;
2223 Statement: IterationStatement ;
2224 Statement: ContinueStatement ;
2225 Statement: BreakStatement ;
2226 Statement: ReturnStatement ;
2227 Statement: WithStatement ;
2228 Statement: LabelledStatement ;
2229 Statement: SwitchStatement ;
2230 Statement: ThrowStatement ;
2231 Statement: TryStatement ;
2232 Statement: DebuggerStatement ;
2235 Block: T_LBRACE StatementListOpt T_RBRACE ;
2237 case $rule_number: {
2238 AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
2239 node->lbraceToken = loc(1);
2240 node->rbraceToken = loc(3);
2245 StatementList: Statement ;
2247 case $rule_number: {
2248 sym(1).Node = new (pool) AST::StatementList(sym(1).Statement);
2252 StatementList: StatementList Statement ;
2254 case $rule_number: {
2255 sym(1).Node = new (pool) AST::StatementList(sym(1).StatementList, sym(2).Statement);
2261 case $rule_number: {
2266 StatementListOpt: StatementList ;
2268 case $rule_number: {
2269 sym(1).Node = sym(1).StatementList->finish ();
2273 VariableStatement: VariableDeclarationKind VariableDeclarationList T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2274 VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ;
2276 case $rule_number: {
2277 AST::VariableStatement *node = new (pool) AST::VariableStatement(
2278 sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
2279 node->declarationKindToken = loc(1);
2280 node->semicolonToken = loc(3);
2285 VariableDeclarationKind: T_CONST ;
2287 case $rule_number: {
2288 sym(1).ival = T_CONST;
2292 VariableDeclarationKind: T_VAR ;
2294 case $rule_number: {
2295 sym(1).ival = T_VAR;
2299 VariableDeclarationList: VariableDeclaration ;
2301 case $rule_number: {
2302 sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
2306 VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ;
2308 case $rule_number: {
2309 AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(
2310 sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
2311 node->commaToken = loc(2);
2316 VariableDeclarationListNotIn: VariableDeclarationNotIn ;
2318 case $rule_number: {
2319 sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
2323 VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ;
2325 case $rule_number: {
2326 sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
2330 VariableDeclaration: JsIdentifier InitialiserOpt ;
2332 case $rule_number: {
2333 AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
2334 node->identifierToken = loc(1);
2339 VariableDeclarationNotIn: JsIdentifier InitialiserNotInOpt ;
2341 case $rule_number: {
2342 AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
2343 node->identifierToken = loc(1);
2348 Initialiser: T_EQ AssignmentExpression ;
2350 case $rule_number: {
2351 // ### TODO: AST for initializer
2358 case $rule_number: {
2363 InitialiserOpt: Initialiser ;
2365 InitialiserNotIn: T_EQ AssignmentExpressionNotIn ;
2367 case $rule_number: {
2368 // ### TODO: AST for initializer
2373 InitialiserNotInOpt: ;
2375 case $rule_number: {
2380 InitialiserNotInOpt: InitialiserNotIn ;
2382 EmptyStatement: T_SEMICOLON ;
2384 case $rule_number: {
2385 AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
2386 node->semicolonToken = loc(1);
2391 ExpressionStatement: Expression T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2392 ExpressionStatement: Expression T_SEMICOLON ;
2394 case $rule_number: {
2395 AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
2396 node->semicolonToken = loc(2);
2401 IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ;
2403 case $rule_number: {
2404 AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement, sym(7).Statement);
2405 node->ifToken = loc(1);
2406 node->lparenToken = loc(2);
2407 node->rparenToken = loc(4);
2408 node->elseToken = loc(6);
2413 IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ;
2415 case $rule_number: {
2416 AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement);
2417 node->ifToken = loc(1);
2418 node->lparenToken = loc(2);
2419 node->rparenToken = loc(4);
2425 IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2426 IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ;
2428 case $rule_number: {
2429 AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression);
2430 node->doToken = loc(1);
2431 node->whileToken = loc(3);
2432 node->lparenToken = loc(4);
2433 node->rparenToken = loc(6);
2434 node->semicolonToken = loc(7);
2439 IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ;
2441 case $rule_number: {
2442 AST::WhileStatement *node = new (pool) AST::WhileStatement(sym(3).Expression, sym(5).Statement);
2443 node->whileToken = loc(1);
2444 node->lparenToken = loc(2);
2445 node->rparenToken = loc(4);
2450 IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
2452 case $rule_number: {
2453 AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression,
2454 sym(5).Expression, sym(7).Expression, sym(9).Statement);
2455 node->forToken = loc(1);
2456 node->lparenToken = loc(2);
2457 node->firstSemicolonToken = loc(4);
2458 node->secondSemicolonToken = loc(6);
2459 node->rparenToken = loc(8);
2464 IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
2466 case $rule_number: {
2467 AST::LocalForStatement *node = new (pool) AST::LocalForStatement(
2468 sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
2469 sym(8).Expression, sym(10).Statement);
2470 node->forToken = loc(1);
2471 node->lparenToken = loc(2);
2472 node->varToken = loc(3);
2473 node->firstSemicolonToken = loc(5);
2474 node->secondSemicolonToken = loc(7);
2475 node->rparenToken = loc(9);
2480 IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ;
2482 case $rule_number: {
2483 AST:: ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression,
2484 sym(5).Expression, sym(7).Statement);
2485 node->forToken = loc(1);
2486 node->lparenToken = loc(2);
2487 node->inToken = loc(4);
2488 node->rparenToken = loc(6);
2493 IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ;
2495 case $rule_number: {
2496 AST::LocalForEachStatement *node = new (pool) AST::LocalForEachStatement(
2497 sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
2498 node->forToken = loc(1);
2499 node->lparenToken = loc(2);
2500 node->varToken = loc(3);
2501 node->inToken = loc(5);
2502 node->rparenToken = loc(7);
2507 ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2508 ContinueStatement: T_CONTINUE T_SEMICOLON ;
2510 case $rule_number: {
2511 AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
2512 node->continueToken = loc(1);
2513 node->semicolonToken = loc(2);
2518 ContinueStatement: T_CONTINUE JsIdentifier T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2519 ContinueStatement: T_CONTINUE JsIdentifier T_SEMICOLON ;
2521 case $rule_number: {
2522 AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2));
2523 node->continueToken = loc(1);
2524 node->identifierToken = loc(2);
2525 node->semicolonToken = loc(3);
2530 BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2531 BreakStatement: T_BREAK T_SEMICOLON ;
2533 case $rule_number: {
2534 AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
2535 node->breakToken = loc(1);
2536 node->semicolonToken = loc(2);
2541 BreakStatement: T_BREAK JsIdentifier T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2542 BreakStatement: T_BREAK JsIdentifier T_SEMICOLON ;
2544 case $rule_number: {
2545 AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2));
2546 node->breakToken = loc(1);
2547 node->identifierToken = loc(2);
2548 node->semicolonToken = loc(3);
2553 ReturnStatement: T_RETURN ExpressionOpt T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2554 ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ;
2556 case $rule_number: {
2557 AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);
2558 node->returnToken = loc(1);
2559 node->semicolonToken = loc(3);
2564 WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ;
2566 case $rule_number: {
2567 AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement);
2568 node->withToken = loc(1);
2569 node->lparenToken = loc(2);
2570 node->rparenToken = loc(4);
2575 SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ;
2577 case $rule_number: {
2578 AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock);
2579 node->switchToken = loc(1);
2580 node->lparenToken = loc(2);
2581 node->rparenToken = loc(4);
2586 CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ;
2588 case $rule_number: {
2589 AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
2590 node->lbraceToken = loc(1);
2591 node->rbraceToken = loc(3);
2596 CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ;
2598 case $rule_number: {
2599 AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
2600 node->lbraceToken = loc(1);
2601 node->rbraceToken = loc(5);
2606 CaseClauses: CaseClause ;
2608 case $rule_number: {
2609 sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
2613 CaseClauses: CaseClauses CaseClause ;
2615 case $rule_number: {
2616 sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
2622 case $rule_number: {
2627 CaseClausesOpt: CaseClauses ;
2629 case $rule_number: {
2630 sym(1).Node = sym(1).CaseClauses->finish ();
2634 CaseClause: T_CASE Expression T_COLON StatementListOpt ;
2636 case $rule_number: {
2637 AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList);
2638 node->caseToken = loc(1);
2639 node->colonToken = loc(3);
2644 DefaultClause: T_DEFAULT T_COLON StatementListOpt ;
2646 case $rule_number: {
2647 AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
2648 node->defaultToken = loc(1);
2649 node->colonToken = loc(2);
2654 LabelledStatement: T_SIGNAL T_COLON Statement ;
2655 /.case $rule_number:./
2657 LabelledStatement: T_PROPERTY T_COLON Statement ;
2659 case $rule_number: {
2660 AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
2661 node->identifierToken = loc(1);
2662 node->colonToken = loc(2);
2667 LabelledStatement: T_IDENTIFIER T_COLON Statement ;
2669 case $rule_number: {
2670 AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
2671 node->identifierToken = loc(1);
2672 node->colonToken = loc(2);
2677 ThrowStatement: T_THROW Expression T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2678 ThrowStatement: T_THROW Expression T_SEMICOLON ;
2680 case $rule_number: {
2681 AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
2682 node->throwToken = loc(1);
2683 node->semicolonToken = loc(3);
2688 TryStatement: T_TRY Block Catch ;
2690 case $rule_number: {
2691 AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
2692 node->tryToken = loc(1);
2697 TryStatement: T_TRY Block Finally ;
2699 case $rule_number: {
2700 AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
2701 node->tryToken = loc(1);
2706 TryStatement: T_TRY Block Catch Finally ;
2708 case $rule_number: {
2709 AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally);
2710 node->tryToken = loc(1);
2715 Catch: T_CATCH T_LPAREN JsIdentifier T_RPAREN Block ;
2717 case $rule_number: {
2718 AST::Catch *node = new (pool) AST::Catch(stringRef(3), sym(5).Block);
2719 node->catchToken = loc(1);
2720 node->lparenToken = loc(2);
2721 node->identifierToken = loc(3);
2722 node->rparenToken = loc(4);
2727 Finally: T_FINALLY Block ;
2729 case $rule_number: {
2730 AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
2731 node->finallyToken = loc(1);
2736 DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
2737 DebuggerStatement: T_DEBUGGER T_SEMICOLON ;
2739 case $rule_number: {
2740 AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
2741 node->debuggerToken = loc(1);
2742 node->semicolonToken = loc(2);
2747 FunctionDeclaration: T_FUNCTION JsIdentifier T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
2749 case $rule_number: {
2750 AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
2751 node->functionToken = loc(1);
2752 node->identifierToken = loc(2);
2753 node->lparenToken = loc(3);
2754 node->rparenToken = loc(5);
2755 node->lbraceToken = loc(6);
2756 node->rbraceToken = loc(8);
2761 FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
2763 case $rule_number: {
2764 AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
2765 node->functionToken = loc(1);
2766 if (! stringRef(2).isNull())
2767 node->identifierToken = loc(2);
2768 node->lparenToken = loc(3);
2769 node->rparenToken = loc(5);
2770 node->lbraceToken = loc(6);
2771 node->rbraceToken = loc(8);
2776 FormalParameterList: JsIdentifier ;
2778 case $rule_number: {
2779 AST::FormalParameterList *node = new (pool) AST::FormalParameterList(stringRef(1));
2780 node->identifierToken = loc(1);
2785 FormalParameterList: FormalParameterList T_COMMA JsIdentifier ;
2787 case $rule_number: {
2788 AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, stringRef(3));
2789 node->commaToken = loc(2);
2790 node->identifierToken = loc(3);
2795 FormalParameterListOpt: ;
2797 case $rule_number: {
2802 FormalParameterListOpt: FormalParameterList ;
2804 case $rule_number: {
2805 sym(1).Node = sym(1).FormalParameterList->finish ();
2811 case $rule_number: {
2816 FunctionBodyOpt: FunctionBody ;
2818 FunctionBody: SourceElements ;
2820 case $rule_number: {
2821 sym(1).Node = new (pool) AST::FunctionBody(sym(1).SourceElements->finish ());
2827 Program: SourceElements ;
2829 case $rule_number: {
2830 sym(1).Node = new (pool) AST::Program(sym(1).SourceElements->finish ());
2834 SourceElements: SourceElement ;
2836 case $rule_number: {
2837 sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElement);
2841 SourceElements: SourceElements SourceElement ;
2843 case $rule_number: {
2844 sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElements, sym(2).SourceElement);
2848 SourceElement: Statement ;
2850 case $rule_number: {
2851 sym(1).Node = new (pool) AST::StatementSourceElement(sym(1).Statement);
2855 SourceElement: FunctionDeclaration ;
2857 case $rule_number: {
2858 sym(1).Node = new (pool) AST::FunctionSourceElement(sym(1).FunctionDeclaration);
2864 case $rule_number: {
2865 stringRef(1) = QStringRef();
2869 IdentifierOpt: JsIdentifier ;
2871 PropertyNameAndValueListOpt: ;
2873 case $rule_number: {
2878 PropertyNameAndValueListOpt: PropertyNameAndValueList ;
2882 action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
2884 } while (action != 0);
2886 if (first_token == last_token) {
2887 const int errorState = state_stack[tos];
2889 // automatic insertion of `;'
2890 if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && lexer->canInsertAutomaticSemicolon(yytoken)) {
2891 SavedToken &tk = token_buffer[0];
2894 tk.spell = yytokenspell;
2897 yylloc = yyprevlloc;
2898 yylloc.offset += yylloc.length;
2899 yylloc.startColumn += yylloc.length;
2902 //const QString msg = qApp->translate("QQmlParser", "Missing `;'");
2903 //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
2905 first_token = &token_buffer[0];
2906 last_token = &token_buffer[1];
2908 yytoken = T_SEMICOLON;
2911 action = errorState;
2918 token_buffer[0].token = yytoken;
2919 token_buffer[0].dval = yylval;
2920 token_buffer[0].spell = yytokenspell;
2921 token_buffer[0].loc = yylloc;
2923 token_buffer[1].token = yytoken = lexer->lex();
2924 token_buffer[1].dval = yylval = lexer->tokenValue();
2925 token_buffer[1].spell = yytokenspell = lexer->tokenSpell();
2926 token_buffer[1].loc = yylloc = location(lexer);
2928 if (t_action(errorState, yytoken)) {
2930 int token = token_buffer[0].token;
2931 if (token < 0 || token >= TERMINAL_COUNT)
2932 msg = qApp->translate("QQmlParser", "Syntax error");
2934 msg = qApp->translate("QQmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
2935 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2937 action = errorState;
2941 static int tokens[] = {
2949 T_RPAREN, T_RBRACKET, T_RBRACE,
2954 T_LPAREN, T_LBRACKET, T_LBRACE,
2959 for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
2960 int a = t_action(errorState, *tk);
2961 if (a > 0 && t_action(a, yytoken)) {
2962 const QString msg = qApp->translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
2963 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2967 yylloc = token_buffer[0].loc;
2970 first_token = &token_buffer[0];
2971 last_token = &token_buffer[2];
2973 action = errorState;
2978 for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
2979 if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM ||
2980 tk == T_FEED_JS_STATEMENT || tk == T_FEED_JS_EXPRESSION ||
2981 tk == T_FEED_JS_SOURCE_ELEMENT)
2984 int a = t_action(errorState, tk);
2985 if (a > 0 && t_action(a, yytoken)) {
2986 const QString msg = qApp->translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
2987 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
2991 yylloc = token_buffer[0].loc;
2994 action = errorState;
2999 const QString msg = qApp->translate("QQmlParser", "Syntax error");
3000 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
3006 QT_QML_END_NAMESPACE
3011 QT_QML_END_NAMESPACE
3015 #endif // QDECLARATIVEJSPARSER_P_H