source: trunk/src/declarative/qml/parser/qdeclarativejs.g

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago

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