← Back to branch summary

~loic.molinari/+junk/qtdeclarative-shadereffectsource-changes

« back to all changes in this revision

Viewing changes to src/qml/qml/parser/qqmljs.g

  • Committer: Loïc Molinari
  • Date: 2012-04-21 17:59:51 UTC
  • Revision ID: loic.molinari@canonical.com-20120421175951-bqx68caaf5zrp76l
Initial import

Show diffs side-by-side

added added

removed removed

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