← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/script/qscript.g

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/script/qscript.g
1
 
----------------------------------------------------------------------------
2
 
--
3
 
--
4
 
--
5
 
--
6
 
--
7
 
--
8
 
--
9
 
--
10
 
--
11
 
----------------------------------------------------------------------------
12
 
 
13
 
%parser         QScriptGrammar
14
 
%decl           qscriptparser_p.h
15
 
%impl           qscriptparser.cpp
16
 
%expect         3
17
 
%expect-rr      1
18
 
 
19
 
%token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="
20
 
%token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"
21
 
%token T_COLON ":"              T_COMMA ";"                 T_CONTINUE "continue"
22
 
%token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"
23
 
%token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."
24
 
%token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="
25
 
%token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"
26
 
%token T_FUNCTION "function"    T_GE ">="                   T_GT ">"
27
 
%token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"
28
 
%token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"
29
 
%token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"
30
 
%token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("
31
 
%token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="
32
 
%token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"
33
 
%token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="
34
 
%token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"
35
 
%token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"
36
 
%token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"
37
 
%token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"
38
 
%token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"
39
 
%token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"
40
 
%token T_STAR_EQ "*="           T_STRING_LITERAL "string literal"
41
 
%token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"
42
 
%token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"
43
 
%token T_VAR "var"              T_VOID "void"               T_WHILE "while"
44
 
%token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="
45
 
%token T_NULL "null"            T_TRUE "true"               T_FALSE "false"
46
 
%token T_CONST "const"
47
 
%token T_DEBUGGER "debugger"
48
 
%token T_RESERVED_WORD "reserved word"
49
 
 
50
 
%start Program
51
 
 
52
 
/.
53
 
/****************************************************************************
54
 
**
55
 
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
56
 
** Contact: Nokia Corporation (qt-info@nokia.com)
57
 
**
58
 
** This file is part of the QtScript module of the Qt Toolkit.
59
 
**
60
 
** $QT_BEGIN_LICENSE:LGPL$
61
 
** Commercial Usage
62
 
** Licensees holding valid Qt Commercial licenses may use this file in
63
 
** accordance with the Qt Commercial License Agreement provided with the
64
 
** Software or, alternatively, in accordance with the terms contained in
65
 
** a written agreement between you and Nokia.
66
 
**
67
 
** GNU Lesser General Public License Usage
68
 
** Alternatively, this file may be used under the terms of the GNU Lesser
69
 
** General Public License version 2.1 as published by the Free Software
70
 
** Foundation and appearing in the file LICENSE.LGPL included in the
71
 
** packaging of this file.  Please review the following information to
72
 
** ensure the GNU Lesser General Public License version 2.1 requirements
73
 
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
74
 
**
75
 
** In addition, as a special exception, Nokia gives you certain
76
 
** additional rights. These rights are described in the Nokia Qt LGPL
77
 
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
78
 
** package.
79
 
**
80
 
** GNU General Public License Usage
81
 
** Alternatively, this file may be used under the terms of the GNU
82
 
** General Public License version 3.0 as published by the Free Software
83
 
** Foundation and appearing in the file LICENSE.GPL included in the
84
 
** packaging of this file.  Please review the following information to
85
 
** ensure the GNU General Public License version 3.0 requirements will be
86
 
** met: http://www.gnu.org/copyleft/gpl.html.
87
 
**
88
 
** If you are unsure which license is appropriate for your use, please
89
 
** contact the sales department at http://www.qtsoftware.com/contact.
90
 
** $QT_END_LICENSE$
91
 
**
92
 
****************************************************************************/
93
 
 
94
 
#include <QtCore/QtDebug>
95
 
 
96
 
#ifndef QT_NO_SCRIPT
97
 
 
98
 
#include <string.h>
99
 
 
100
 
#include "qscriptengine.h"
101
 
#include "qscriptengine_p.h"
102
 
#include "qscriptvalueimpl_p.h"
103
 
#include "qscriptcontext_p.h"
104
 
#include "qscriptmember_p.h"
105
 
#include "qscriptobject_p.h"
106
 
#include "qscriptlexer_p.h"
107
 
#include "qscriptast_p.h"
108
 
#include "qscriptnodepool_p.h"
109
 
 
110
 
#define Q_SCRIPT_UPDATE_POSITION(node, startloc, endloc) do { \
111
 
    node->startLine = startloc.startLine; \
112
 
    node->startColumn = startloc.startColumn; \
113
 
    node->endLine = endloc.endLine; \
114
 
    node->endColumn = endloc.endColumn; \
115
 
} while (0)
116
 
 
117
 
./
118
 
 
119
 
/:
120
 
/****************************************************************************
121
 
**
122
 
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
123
 
** Contact: Nokia Corporation (qt-info@nokia.com)
124
 
**
125
 
** This file is part of the QtScript module of the Qt Toolkit.
126
 
**
127
 
** $QT_BEGIN_LICENSE:LGPL$
128
 
** Commercial Usage
129
 
** Licensees holding valid Qt Commercial licenses may use this file in
130
 
** accordance with the Qt Commercial License Agreement provided with the
131
 
** Software or, alternatively, in accordance with the terms contained in
132
 
** a written agreement between you and Nokia.
133
 
**
134
 
** GNU Lesser General Public License Usage
135
 
** Alternatively, this file may be used under the terms of the GNU Lesser
136
 
** General Public License version 2.1 as published by the Free Software
137
 
** Foundation and appearing in the file LICENSE.LGPL included in the
138
 
** packaging of this file.  Please review the following information to
139
 
** ensure the GNU Lesser General Public License version 2.1 requirements
140
 
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
141
 
**
142
 
** In addition, as a special exception, Nokia gives you certain
143
 
** additional rights. These rights are described in the Nokia Qt LGPL
144
 
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
145
 
** package.
146
 
**
147
 
** GNU General Public License Usage
148
 
** Alternatively, this file may be used under the terms of the GNU
149
 
** General Public License version 3.0 as published by the Free Software
150
 
** Foundation and appearing in the file LICENSE.GPL included in the
151
 
** packaging of this file.  Please review the following information to
152
 
** ensure the GNU General Public License version 3.0 requirements will be
153
 
** met: http://www.gnu.org/copyleft/gpl.html.
154
 
**
155
 
** If you are unsure which license is appropriate for your use, please
156
 
** contact the sales department at http://www.qtsoftware.com/contact.
157
 
** $QT_END_LICENSE$
158
 
**
159
 
****************************************************************************/
160
 
 
161
 
//
162
 
//  W A R N I N G
163
 
//  -------------
164
 
//
165
 
// This file is not part of the Qt API.  It exists purely as an
166
 
// implementation detail.  This header file may change from version to
167
 
// version without notice, or even be removed.
168
 
//
169
 
// We mean it.
170
 
//
171
 
 
172
 
//
173
 
// This file is automatically generated from qscript.g.
174
 
// Changes will be lost.
175
 
//
176
 
 
177
 
#ifndef QSCRIPTPARSER_P_H
178
 
#define QSCRIPTPARSER_P_H
179
 
 
180
 
#include "qscriptgrammar_p.h"
181
 
 
182
 
#ifndef QT_NO_SCRIPT
183
 
 
184
 
#include "qscriptastfwd_p.h"
185
 
 
186
 
QT_BEGIN_NAMESPACE
187
 
 
188
 
class QString;
189
 
class QScriptEnginePrivate;
190
 
class QScriptNameIdImpl;
191
 
 
192
 
class QScriptParser: protected $table
193
 
{
194
 
public:
195
 
    union Value {
196
 
      int ival;
197
 
      double dval;
198
 
      QScriptNameIdImpl *sval;
199
 
      QScript::AST::ArgumentList *ArgumentList;
200
 
      QScript::AST::CaseBlock *CaseBlock;
201
 
      QScript::AST::CaseClause *CaseClause;
202
 
      QScript::AST::CaseClauses *CaseClauses;
203
 
      QScript::AST::Catch *Catch;
204
 
      QScript::AST::DefaultClause *DefaultClause;
205
 
      QScript::AST::ElementList *ElementList;
206
 
      QScript::AST::Elision *Elision;
207
 
      QScript::AST::ExpressionNode *Expression;
208
 
      QScript::AST::Finally *Finally;
209
 
      QScript::AST::FormalParameterList *FormalParameterList;
210
 
      QScript::AST::FunctionBody *FunctionBody;
211
 
      QScript::AST::FunctionDeclaration *FunctionDeclaration;
212
 
      QScript::AST::Node *Node;
213
 
      QScript::AST::PropertyName *PropertyName;
214
 
      QScript::AST::PropertyNameAndValueList *PropertyNameAndValueList;
215
 
      QScript::AST::SourceElement *SourceElement;
216
 
      QScript::AST::SourceElements *SourceElements;
217
 
      QScript::AST::Statement *Statement;
218
 
      QScript::AST::StatementList *StatementList;
219
 
      QScript::AST::VariableDeclaration *VariableDeclaration;
220
 
      QScript::AST::VariableDeclarationList *VariableDeclarationList;
221
 
    };
222
 
 
223
 
    struct Location {
224
 
      int startLine;
225
 
      int startColumn;
226
 
      int endLine;
227
 
      int endColumn;
228
 
    };
229
 
 
230
 
public:
231
 
    QScriptParser();
232
 
    ~QScriptParser();
233
 
 
234
 
    bool parse(QScriptEnginePrivate *driver);
235
 
 
236
 
    inline QString errorMessage() const
237
 
    { return error_message; }
238
 
    inline int errorLineNumber() const
239
 
    { return error_lineno; }
240
 
    inline int errorColumnNumber() const
241
 
    { return error_column; }
242
 
 
243
 
protected:
244
 
    inline void reallocateStack();
245
 
 
246
 
    inline Value &sym(int index)
247
 
    { return sym_stack [tos + index - 1]; }
248
 
 
249
 
    inline Location &loc(int index)
250
 
    { return location_stack [tos + index - 2]; }
251
 
 
252
 
protected:
253
 
    int tos;
254
 
    int stack_size;
255
 
    Value *sym_stack;
256
 
    int *state_stack;
257
 
    Location *location_stack;
258
 
    QString error_message;
259
 
    int error_lineno;
260
 
    int error_column;
261
 
};
262
 
 
263
 
inline void QScriptParser::reallocateStack()
264
 
{
265
 
    if (! stack_size)
266
 
        stack_size = 128;
267
 
    else
268
 
        stack_size <<= 1;
269
 
 
270
 
    sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
271
 
    state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
272
 
    location_stack = reinterpret_cast<Location*> (qRealloc(location_stack, stack_size * sizeof(Location)));
273
 
}
274
 
 
275
 
:/
276
 
 
277
 
 
278
 
/.
279
 
 
280
 
#include "qscriptparser_p.h"
281
 
 
282
 
//
283
 
// This file is automatically generated from qscript.g.
284
 
// Changes will be lost.
285
 
//
286
 
 
287
 
QT_BEGIN_NAMESPACE
288
 
 
289
 
inline static bool automatic(QScriptEnginePrivate *driver, int token)
290
 
{
291
 
    return token == $table::T_RBRACE
292
 
        || token == 0
293
 
        || driver->lexer()->prevTerminator();
294
 
}
295
 
 
296
 
 
297
 
QScriptParser::QScriptParser():
298
 
    tos(0),
299
 
    stack_size(0),
300
 
    sym_stack(0),
301
 
    state_stack(0),
302
 
    location_stack(0),
303
 
    error_lineno(0),
304
 
    error_column(0)
305
 
{
306
 
}
307
 
 
308
 
QScriptParser::~QScriptParser()
309
 
{
310
 
    if (stack_size) {
311
 
        qFree(sym_stack);
312
 
        qFree(state_stack);
313
 
        qFree(location_stack);
314
 
    }
315
 
}
316
 
 
317
 
static inline QScriptParser::Location location(QScript::Lexer *lexer)
318
 
{
319
 
    QScriptParser::Location loc;
320
 
    loc.startLine = lexer->startLineNo();
321
 
    loc.startColumn = lexer->startColumnNo();
322
 
    loc.endLine = lexer->endLineNo();
323
 
    loc.endColumn = lexer->endColumnNo();
324
 
    return loc;
325
 
}
326
 
 
327
 
bool QScriptParser::parse(QScriptEnginePrivate *driver)
328
 
{
329
 
  const int INITIAL_STATE = 0;
330
 
  QScript::Lexer *lexer = driver->lexer();
331
 
 
332
 
  int yytoken = -1;
333
 
  int saved_yytoken = -1;
334
 
 
335
 
  reallocateStack();
336
 
 
337
 
  tos = 0;
338
 
  state_stack[++tos] = INITIAL_STATE;
339
 
 
340
 
  while (true)
341
 
    {
342
 
      const int state = state_stack [tos];
343
 
      if (yytoken == -1 && - TERMINAL_COUNT != action_index [state])
344
 
        {
345
 
          if (saved_yytoken == -1)
346
 
            {
347
 
              yytoken = lexer->lex();
348
 
              location_stack [tos] = location(lexer);
349
 
            }
350
 
          else
351
 
            {
352
 
              yytoken = saved_yytoken;
353
 
              saved_yytoken = -1;
354
 
            }
355
 
        }
356
 
 
357
 
      int act = t_action (state, yytoken);
358
 
 
359
 
      if (act == ACCEPT_STATE)
360
 
        return true;
361
 
 
362
 
      else if (act > 0)
363
 
        {
364
 
          if (++tos == stack_size)
365
 
            reallocateStack();
366
 
 
367
 
          sym_stack [tos].dval = lexer->dval ();
368
 
          state_stack [tos] = act;
369
 
          location_stack [tos] = location(lexer);
370
 
          yytoken = -1;
371
 
        }
372
 
 
373
 
      else if (act < 0)
374
 
        {
375
 
          int r = - act - 1;
376
 
 
377
 
          tos -= rhs [r];
378
 
          act = state_stack [tos++];
379
 
 
380
 
          switch (r) {
381
 
./
382
 
 
383
 
PrimaryExpression: T_THIS ;
384
 
/.
385
 
case $rule_number: {
386
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ThisExpression> (driver->nodePool());
387
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
388
 
} break;
389
 
./
390
 
 
391
 
PrimaryExpression: T_IDENTIFIER ;
392
 
/.
393
 
case $rule_number: {
394
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);
395
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
396
 
} break;
397
 
./
398
 
 
399
 
PrimaryExpression: T_NULL ;
400
 
/.
401
 
case $rule_number: {
402
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NullExpression> (driver->nodePool());
403
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
404
 
} break;
405
 
./
406
 
 
407
 
PrimaryExpression: T_TRUE ;
408
 
/.
409
 
case $rule_number: {
410
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TrueLiteral> (driver->nodePool());
411
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
412
 
} break;
413
 
./
414
 
 
415
 
PrimaryExpression: T_FALSE ;
416
 
/.
417
 
case $rule_number: {
418
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FalseLiteral> (driver->nodePool());
419
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
420
 
} break;
421
 
./
422
 
 
423
 
PrimaryExpression: T_NUMERIC_LITERAL ;
424
 
/.
425
 
case $rule_number: {
426
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NumericLiteral> (driver->nodePool(), sym(1).dval);
427
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
428
 
} break;
429
 
./
430
 
 
431
 
PrimaryExpression: T_STRING_LITERAL ;
432
 
/.
433
 
case $rule_number: {
434
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StringLiteral> (driver->nodePool(), sym(1).sval);
435
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
436
 
} break;
437
 
./
438
 
 
439
 
PrimaryExpression: T_DIVIDE_ ;
440
 
/:
441
 
#define Q_SCRIPT_REGEXPLITERAL_RULE1 $rule_number
442
 
:/
443
 
/.
444
 
case $rule_number: {
445
 
  bool rx = lexer->scanRegExp(QScript::Lexer::NoPrefix);
446
 
  if (!rx) {
447
 
      error_message = lexer->errorMessage();
448
 
      error_lineno = lexer->startLineNo();
449
 
      error_column = lexer->startColumnNo();
450
 
      return false;
451
 
  }
452
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
453
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
454
 
} break;
455
 
./
456
 
 
457
 
PrimaryExpression: T_DIVIDE_EQ ;
458
 
/:
459
 
#define Q_SCRIPT_REGEXPLITERAL_RULE2 $rule_number
460
 
:/
461
 
/.
462
 
case $rule_number: {
463
 
  bool rx = lexer->scanRegExp(QScript::Lexer::EqualPrefix);
464
 
  if (!rx) {
465
 
      error_message = lexer->errorMessage();
466
 
      error_lineno = lexer->startLineNo();
467
 
      error_column = lexer->startColumnNo();
468
 
      return false;
469
 
  }
470
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
471
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
472
 
} break;
473
 
./
474
 
 
475
 
PrimaryExpression: T_LBRACKET ElisionOpt T_RBRACKET ;
476
 
/.
477
 
case $rule_number: {
478
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision);
479
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
480
 
} break;
481
 
./
482
 
 
483
 
PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ;
484
 
/.
485
 
case $rule_number: {
486
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ());
487
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
488
 
} break;
489
 
./
490
 
 
491
 
PrimaryExpression: T_LBRACKET ElementList T_COMMA ElisionOpt T_RBRACKET ;
492
 
/.
493
 
case $rule_number: {
494
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (), sym(4).Elision);
495
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
496
 
} break;
497
 
./
498
 
 
499
 
 
500
 
PrimaryExpression: T_LBRACE PropertyNameAndValueListOpt T_RBRACE ;
501
 
/.
502
 
case $rule_number: {
503
 
  if (sym(2).Node)
504
 
    sym(1).Node = QScript::makeAstNode<QScript::AST::ObjectLiteral> (driver->nodePool(), sym(2).PropertyNameAndValueList->finish ());
505
 
  else
506
 
    sym(1).Node = QScript::makeAstNode<QScript::AST::ObjectLiteral> (driver->nodePool());
507
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
508
 
} break;
509
 
./
510
 
 
511
 
PrimaryExpression: T_LBRACE PropertyNameAndValueList T_COMMA T_RBRACE ;
512
 
/.
513
 
case $rule_number: {
514
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ObjectLiteral> (driver->nodePool(), sym(2).PropertyNameAndValueList->finish ());
515
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
516
 
} break;
517
 
./
518
 
 
519
 
PrimaryExpression: T_LPAREN Expression T_RPAREN ;
520
 
/.
521
 
case $rule_number: {
522
 
  sym(1) = sym(2);
523
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
524
 
} break;
525
 
./
526
 
 
527
 
ElementList: ElisionOpt AssignmentExpression ;
528
 
/.
529
 
case $rule_number: {
530
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ElementList> (driver->nodePool(), sym(1).Elision, sym(2).Expression);
531
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
532
 
} break;
533
 
./
534
 
 
535
 
ElementList: ElementList T_COMMA ElisionOpt AssignmentExpression ;
536
 
/.
537
 
case $rule_number: {
538
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision, sym(4).Expression);
539
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
540
 
} break;
541
 
./
542
 
 
543
 
Elision: T_COMMA ;
544
 
/.
545
 
case $rule_number: {
546
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Elision> (driver->nodePool());
547
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
548
 
} break;
549
 
./
550
 
 
551
 
Elision: Elision T_COMMA ;
552
 
/.
553
 
case $rule_number: {
554
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Elision> (driver->nodePool(), sym(1).Elision);
555
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
556
 
} break;
557
 
./
558
 
 
559
 
ElisionOpt: ;
560
 
/.
561
 
case $rule_number: {
562
 
  sym(1).Node = 0;
563
 
} break;
564
 
./
565
 
 
566
 
ElisionOpt: Elision ;
567
 
/.
568
 
case $rule_number: {
569
 
  sym(1).Elision = sym(1).Elision->finish ();
570
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
571
 
} break;
572
 
./
573
 
 
574
 
PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ;
575
 
/.
576
 
case $rule_number: {
577
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PropertyNameAndValueList> (driver->nodePool(), sym(1).PropertyName, sym(3).Expression);
578
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
579
 
} break;
580
 
./
581
 
 
582
 
PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ;
583
 
/.
584
 
case $rule_number: {
585
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PropertyNameAndValueList> (driver->nodePool(), sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
586
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
587
 
} break;
588
 
./
589
 
 
590
 
PropertyName: T_IDENTIFIER ;
591
 
/.
592
 
case $rule_number: {
593
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
594
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
595
 
} break;
596
 
./
597
 
 
598
 
PropertyName: T_STRING_LITERAL ;
599
 
/.
600
 
case $rule_number: {
601
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval);
602
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
603
 
} break;
604
 
./
605
 
 
606
 
PropertyName: T_NUMERIC_LITERAL ;
607
 
/.
608
 
case $rule_number: {
609
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval);
610
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
611
 
} break;
612
 
./
613
 
 
614
 
PropertyName: ReservedIdentifier ;
615
 
/.
616
 
case $rule_number: {
617
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
618
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
619
 
} break;
620
 
./
621
 
 
622
 
ReservedIdentifier: T_BREAK ;
623
 
/.
624
 
case $rule_number:
625
 
./
626
 
ReservedIdentifier: T_CASE ;
627
 
/.
628
 
case $rule_number:
629
 
./
630
 
ReservedIdentifier: T_CATCH ;
631
 
/.
632
 
case $rule_number:
633
 
./
634
 
ReservedIdentifier: T_CONTINUE ;
635
 
/.
636
 
case $rule_number:
637
 
./
638
 
ReservedIdentifier: T_DEFAULT ;
639
 
/.
640
 
case $rule_number:
641
 
./
642
 
ReservedIdentifier: T_DELETE ;
643
 
/.
644
 
case $rule_number:
645
 
./
646
 
ReservedIdentifier: T_DO ;
647
 
/.
648
 
case $rule_number:
649
 
./
650
 
ReservedIdentifier: T_ELSE ;
651
 
/.
652
 
case $rule_number:
653
 
./
654
 
ReservedIdentifier: T_FALSE ;
655
 
/.
656
 
case $rule_number:
657
 
./
658
 
ReservedIdentifier: T_FINALLY ;
659
 
/.
660
 
case $rule_number:
661
 
./
662
 
ReservedIdentifier: T_FOR ;
663
 
/.
664
 
case $rule_number:
665
 
./
666
 
ReservedIdentifier: T_FUNCTION ;
667
 
/.
668
 
case $rule_number:
669
 
./
670
 
ReservedIdentifier: T_IF ;
671
 
/.
672
 
case $rule_number:
673
 
./
674
 
ReservedIdentifier: T_IN ;
675
 
/.
676
 
case $rule_number:
677
 
./
678
 
ReservedIdentifier: T_INSTANCEOF ;
679
 
/.
680
 
case $rule_number:
681
 
./
682
 
ReservedIdentifier: T_NEW ;
683
 
/.
684
 
case $rule_number:
685
 
./
686
 
ReservedIdentifier: T_NULL ;
687
 
/.
688
 
case $rule_number:
689
 
./
690
 
ReservedIdentifier: T_RETURN ;
691
 
/.
692
 
case $rule_number:
693
 
./
694
 
ReservedIdentifier: T_SWITCH ;
695
 
/.
696
 
case $rule_number:
697
 
./
698
 
ReservedIdentifier: T_THIS ;
699
 
/.
700
 
case $rule_number:
701
 
./
702
 
ReservedIdentifier: T_THROW ;
703
 
/.
704
 
case $rule_number:
705
 
./
706
 
ReservedIdentifier: T_TRUE ;
707
 
/.
708
 
case $rule_number:
709
 
./
710
 
ReservedIdentifier: T_TRY ;
711
 
/.
712
 
case $rule_number:
713
 
./
714
 
ReservedIdentifier: T_TYPEOF ;
715
 
/.
716
 
case $rule_number:
717
 
./
718
 
ReservedIdentifier: T_VAR ;
719
 
/.
720
 
case $rule_number:
721
 
./
722
 
ReservedIdentifier: T_VOID ;
723
 
/.
724
 
case $rule_number:
725
 
./
726
 
ReservedIdentifier: T_WHILE ;
727
 
/.
728
 
case $rule_number:
729
 
./
730
 
ReservedIdentifier: T_CONST ;
731
 
/.
732
 
case $rule_number:
733
 
./
734
 
ReservedIdentifier: T_DEBUGGER ;
735
 
/.
736
 
case $rule_number:
737
 
./
738
 
ReservedIdentifier: T_RESERVED_WORD ;
739
 
/.
740
 
case $rule_number:
741
 
./
742
 
ReservedIdentifier: T_WITH ;
743
 
/.
744
 
case $rule_number:
745
 
{
746
 
  sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
747
 
} break;
748
 
./
749
 
 
750
 
PropertyIdentifier: T_IDENTIFIER ;
751
 
PropertyIdentifier: ReservedIdentifier ;
752
 
 
753
 
MemberExpression: PrimaryExpression ;
754
 
MemberExpression: FunctionExpression ;
755
 
 
756
 
MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ;
757
 
/.
758
 
case $rule_number: {
759
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
760
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
761
 
} break;
762
 
./
763
 
 
764
 
MemberExpression: MemberExpression T_DOT PropertyIdentifier ;
765
 
/.
766
 
case $rule_number: {
767
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
768
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
769
 
} break;
770
 
./
771
 
 
772
 
MemberExpression: T_NEW MemberExpression Arguments ;
773
 
/.
774
 
case $rule_number: {
775
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(3).ArgumentList);
776
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
777
 
} break;
778
 
./
779
 
 
780
 
NewExpression: MemberExpression ;
781
 
 
782
 
NewExpression: T_NEW NewExpression ;
783
 
/.
784
 
case $rule_number: {
785
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NewExpression> (driver->nodePool(), sym(2).Expression);
786
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
787
 
} break;
788
 
./
789
 
 
790
 
CallExpression: MemberExpression Arguments ;
791
 
/.
792
 
case $rule_number: {
793
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(2).ArgumentList);
794
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
795
 
} break;
796
 
./
797
 
 
798
 
CallExpression: CallExpression Arguments ;
799
 
/.
800
 
case $rule_number: {
801
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(2).ArgumentList);
802
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
803
 
} break;
804
 
./
805
 
 
806
 
CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ;
807
 
/.
808
 
case $rule_number: {
809
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
810
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
811
 
} break;
812
 
./
813
 
 
814
 
CallExpression: CallExpression T_DOT PropertyIdentifier ;
815
 
/.
816
 
case $rule_number: {
817
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
818
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
819
 
} break;
820
 
./
821
 
 
822
 
Arguments: T_LPAREN T_RPAREN ;
823
 
/.
824
 
case $rule_number: {
825
 
  sym(1).Node = 0;
826
 
} break;
827
 
./
828
 
 
829
 
Arguments: T_LPAREN ArgumentList T_RPAREN ;
830
 
/.
831
 
case $rule_number: {
832
 
  sym(1).Node = sym(2).ArgumentList->finish ();
833
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
834
 
} break;
835
 
./
836
 
 
837
 
ArgumentList: AssignmentExpression ;
838
 
/.
839
 
case $rule_number: {
840
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArgumentList> (driver->nodePool(), sym(1).Expression);
841
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
842
 
} break;
843
 
./
844
 
 
845
 
ArgumentList: ArgumentList T_COMMA AssignmentExpression ;
846
 
/.
847
 
case $rule_number: {
848
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression);
849
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
850
 
} break;
851
 
./
852
 
 
853
 
LeftHandSideExpression: NewExpression ;
854
 
LeftHandSideExpression: CallExpression ;
855
 
PostfixExpression: LeftHandSideExpression ;
856
 
 
857
 
PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ;
858
 
/.
859
 
case $rule_number: {
860
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression);
861
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
862
 
} break;
863
 
./
864
 
 
865
 
PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ;
866
 
/.
867
 
case $rule_number: {
868
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression);
869
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
870
 
} break;
871
 
./
872
 
 
873
 
UnaryExpression: PostfixExpression ;
874
 
 
875
 
UnaryExpression: T_DELETE UnaryExpression ;
876
 
/.
877
 
case $rule_number: {
878
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DeleteExpression> (driver->nodePool(), sym(2).Expression);
879
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
880
 
} break;
881
 
./
882
 
 
883
 
UnaryExpression: T_VOID UnaryExpression ;
884
 
/.
885
 
case $rule_number: {
886
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VoidExpression> (driver->nodePool(), sym(2).Expression);
887
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
888
 
} break;
889
 
./
890
 
 
891
 
UnaryExpression: T_TYPEOF UnaryExpression ;
892
 
/.
893
 
case $rule_number: {
894
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression);
895
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
896
 
} break;
897
 
./
898
 
 
899
 
UnaryExpression: T_PLUS_PLUS UnaryExpression ;
900
 
/.
901
 
case $rule_number: {
902
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression);
903
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
904
 
} break;
905
 
./
906
 
 
907
 
UnaryExpression: T_MINUS_MINUS UnaryExpression ;
908
 
/.
909
 
case $rule_number: {
910
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression);
911
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
912
 
} break;
913
 
./
914
 
 
915
 
UnaryExpression: T_PLUS UnaryExpression ;
916
 
/.
917
 
case $rule_number: {
918
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression);
919
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
920
 
} break;
921
 
./
922
 
 
923
 
UnaryExpression: T_MINUS UnaryExpression ;
924
 
/.
925
 
case $rule_number: {
926
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression);
927
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
928
 
} break;
929
 
./
930
 
 
931
 
UnaryExpression: T_TILDE UnaryExpression ;
932
 
/.
933
 
case $rule_number: {
934
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TildeExpression> (driver->nodePool(), sym(2).Expression);
935
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
936
 
} break;
937
 
./
938
 
 
939
 
UnaryExpression: T_NOT UnaryExpression ;
940
 
/.
941
 
case $rule_number: {
942
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NotExpression> (driver->nodePool(), sym(2).Expression);
943
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
944
 
} break;
945
 
./
946
 
 
947
 
MultiplicativeExpression: UnaryExpression ;
948
 
 
949
 
MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ;
950
 
/.
951
 
case $rule_number: {
952
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Mul, sym(3).Expression);
953
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
954
 
} break;
955
 
./
956
 
 
957
 
MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ;
958
 
/.
959
 
case $rule_number: {
960
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Div, sym(3).Expression);
961
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
962
 
} break;
963
 
./
964
 
 
965
 
MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ;
966
 
/.
967
 
case $rule_number: {
968
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Mod, sym(3).Expression);
969
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
970
 
} break;
971
 
./
972
 
 
973
 
AdditiveExpression: MultiplicativeExpression ;
974
 
 
975
 
AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ;
976
 
/.
977
 
case $rule_number: {
978
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Add, sym(3).Expression);
979
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
980
 
} break;
981
 
./
982
 
 
983
 
AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ;
984
 
/.
985
 
case $rule_number: {
986
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Sub, sym(3).Expression);
987
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
988
 
} break;
989
 
./
990
 
 
991
 
ShiftExpression: AdditiveExpression ;
992
 
 
993
 
ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ;
994
 
/.
995
 
case $rule_number: {
996
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::LShift, sym(3).Expression);
997
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
998
 
} break;
999
 
./
1000
 
 
1001
 
ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ;
1002
 
/.
1003
 
case $rule_number: {
1004
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::RShift, sym(3).Expression);
1005
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1006
 
} break;
1007
 
./
1008
 
 
1009
 
ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ;
1010
 
/.
1011
 
case $rule_number: {
1012
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::URShift, sym(3).Expression);
1013
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1014
 
} break;
1015
 
./
1016
 
 
1017
 
RelationalExpression: ShiftExpression ;
1018
 
 
1019
 
RelationalExpression: RelationalExpression T_LT ShiftExpression ;
1020
 
/.
1021
 
case $rule_number: {
1022
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Lt, sym(3).Expression);
1023
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1024
 
} break;
1025
 
./
1026
 
 
1027
 
RelationalExpression: RelationalExpression T_GT ShiftExpression ;
1028
 
/.
1029
 
case $rule_number: {
1030
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Gt, sym(3).Expression);
1031
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1032
 
} break;
1033
 
./
1034
 
 
1035
 
RelationalExpression: RelationalExpression T_LE ShiftExpression ;
1036
 
/.
1037
 
case $rule_number: {
1038
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Le, sym(3).Expression);
1039
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1040
 
} break;
1041
 
./
1042
 
 
1043
 
RelationalExpression: RelationalExpression T_GE ShiftExpression ;
1044
 
/.
1045
 
case $rule_number: {
1046
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Ge, sym(3).Expression);
1047
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1048
 
} break;
1049
 
./
1050
 
 
1051
 
RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ;
1052
 
/.
1053
 
case $rule_number: {
1054
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::InstanceOf, sym(3).Expression);
1055
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1056
 
} break;
1057
 
./
1058
 
 
1059
 
RelationalExpression: RelationalExpression T_IN ShiftExpression ;
1060
 
/.
1061
 
case $rule_number: {
1062
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::In, sym(3).Expression);
1063
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1064
 
} break;
1065
 
./
1066
 
 
1067
 
RelationalExpressionNotIn: ShiftExpression ;
1068
 
 
1069
 
RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ;
1070
 
/.
1071
 
case $rule_number: {
1072
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Lt, sym(3).Expression);
1073
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1074
 
} break;
1075
 
./
1076
 
 
1077
 
RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ;
1078
 
/.
1079
 
case $rule_number: {
1080
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Gt, sym(3).Expression);
1081
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1082
 
} break;
1083
 
./
1084
 
 
1085
 
RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ;
1086
 
/.
1087
 
case $rule_number: {
1088
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Le, sym(3).Expression);
1089
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1090
 
} break;
1091
 
./
1092
 
 
1093
 
RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ;
1094
 
/.
1095
 
case $rule_number: {
1096
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Ge, sym(3).Expression);
1097
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1098
 
} break;
1099
 
./
1100
 
 
1101
 
RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ;
1102
 
/.
1103
 
case $rule_number: {
1104
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::InstanceOf, sym(3).Expression);
1105
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1106
 
} break;
1107
 
./
1108
 
 
1109
 
EqualityExpression: RelationalExpression ;
1110
 
 
1111
 
EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ;
1112
 
/.
1113
 
case $rule_number: {
1114
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Equal, sym(3).Expression);
1115
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1116
 
} break;
1117
 
./
1118
 
 
1119
 
EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ;
1120
 
/.
1121
 
case $rule_number: {
1122
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::NotEqual, sym(3).Expression);
1123
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1124
 
} break;
1125
 
./
1126
 
 
1127
 
EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ;
1128
 
/.
1129
 
case $rule_number: {
1130
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictEqual, sym(3).Expression);
1131
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1132
 
} break;
1133
 
./
1134
 
 
1135
 
EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ;
1136
 
/.
1137
 
case $rule_number: {
1138
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictNotEqual, sym(3).Expression);
1139
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1140
 
} break;
1141
 
./
1142
 
 
1143
 
EqualityExpressionNotIn: RelationalExpressionNotIn ;
1144
 
 
1145
 
EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ;
1146
 
/.
1147
 
case $rule_number: {
1148
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Equal, sym(3).Expression);
1149
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1150
 
} break;
1151
 
./
1152
 
 
1153
 
EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn;
1154
 
/.
1155
 
case $rule_number: {
1156
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::NotEqual, sym(3).Expression);
1157
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1158
 
} break;
1159
 
./
1160
 
 
1161
 
EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ;
1162
 
/.
1163
 
case $rule_number: {
1164
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictEqual, sym(3).Expression);
1165
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1166
 
} break;
1167
 
./
1168
 
 
1169
 
EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ;
1170
 
/.
1171
 
case $rule_number: {
1172
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictNotEqual, sym(3).Expression);
1173
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1174
 
} break;
1175
 
./
1176
 
 
1177
 
BitwiseANDExpression: EqualityExpression ;
1178
 
 
1179
 
BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ;
1180
 
/.
1181
 
case $rule_number: {
1182
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitAnd, sym(3).Expression);
1183
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1184
 
} break;
1185
 
./
1186
 
 
1187
 
BitwiseANDExpressionNotIn: EqualityExpressionNotIn ;
1188
 
 
1189
 
BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ;
1190
 
/.
1191
 
case $rule_number: {
1192
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitAnd, sym(3).Expression);
1193
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1194
 
} break;
1195
 
./
1196
 
 
1197
 
BitwiseXORExpression: BitwiseANDExpression ;
1198
 
 
1199
 
BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ;
1200
 
/.
1201
 
case $rule_number: {
1202
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitXor, sym(3).Expression);
1203
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1204
 
} break;
1205
 
./
1206
 
 
1207
 
BitwiseXORExpressionNotIn: BitwiseANDExpressionNotIn ;
1208
 
 
1209
 
BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ;
1210
 
/.
1211
 
case $rule_number: {
1212
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitXor, sym(3).Expression);
1213
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1214
 
} break;
1215
 
./
1216
 
 
1217
 
BitwiseORExpression: BitwiseXORExpression ;
1218
 
 
1219
 
BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ;
1220
 
/.
1221
 
case $rule_number: {
1222
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitOr, sym(3).Expression);
1223
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1224
 
} break;
1225
 
./
1226
 
 
1227
 
BitwiseORExpressionNotIn: BitwiseXORExpressionNotIn ;
1228
 
 
1229
 
BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ;
1230
 
/.
1231
 
case $rule_number: {
1232
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitOr, sym(3).Expression);
1233
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1234
 
} break;
1235
 
./
1236
 
 
1237
 
LogicalANDExpression: BitwiseORExpression ;
1238
 
 
1239
 
LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ;
1240
 
/.
1241
 
case $rule_number: {
1242
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::And, sym(3).Expression);
1243
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1244
 
} break;
1245
 
./
1246
 
 
1247
 
LogicalANDExpressionNotIn: BitwiseORExpressionNotIn ;
1248
 
 
1249
 
LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ;
1250
 
/.
1251
 
case $rule_number: {
1252
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::And, sym(3).Expression);
1253
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1254
 
} break;
1255
 
./
1256
 
 
1257
 
LogicalORExpression: LogicalANDExpression ;
1258
 
 
1259
 
LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ;
1260
 
/.
1261
 
case $rule_number: {
1262
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Or, sym(3).Expression);
1263
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1264
 
} break;
1265
 
./
1266
 
 
1267
 
LogicalORExpressionNotIn: LogicalANDExpressionNotIn ;
1268
 
 
1269
 
LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ;
1270
 
/.
1271
 
case $rule_number: {
1272
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Or, sym(3).Expression);
1273
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1274
 
} break;
1275
 
./
1276
 
 
1277
 
ConditionalExpression: LogicalORExpression ;
1278
 
 
1279
 
ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ;
1280
 
/.
1281
 
case $rule_number: {
1282
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression, sym(5).Expression);
1283
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1284
 
} break;
1285
 
./
1286
 
 
1287
 
ConditionalExpressionNotIn: LogicalORExpressionNotIn ;
1288
 
 
1289
 
ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ;
1290
 
/.
1291
 
case $rule_number: {
1292
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression, sym(5).Expression);
1293
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1294
 
} break;
1295
 
./
1296
 
 
1297
 
AssignmentExpression: ConditionalExpression ;
1298
 
 
1299
 
AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ;
1300
 
/.
1301
 
case $rule_number: {
1302
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, sym(2).ival, sym(3).Expression);
1303
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1304
 
} break;
1305
 
./
1306
 
 
1307
 
AssignmentExpressionNotIn: ConditionalExpressionNotIn ;
1308
 
 
1309
 
AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ;
1310
 
/.
1311
 
case $rule_number: {
1312
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, sym(2).ival, sym(3).Expression);
1313
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1314
 
} break;
1315
 
./
1316
 
 
1317
 
AssignmentOperator: T_EQ ;
1318
 
/.
1319
 
case $rule_number: {
1320
 
  sym(1).ival = QSOperator::Assign;
1321
 
} break;
1322
 
./
1323
 
 
1324
 
AssignmentOperator: T_STAR_EQ ;
1325
 
/.
1326
 
case $rule_number: {
1327
 
  sym(1).ival = QSOperator::InplaceMul;
1328
 
} break;
1329
 
./
1330
 
 
1331
 
AssignmentOperator: T_DIVIDE_EQ ;
1332
 
/.
1333
 
case $rule_number: {
1334
 
  sym(1).ival = QSOperator::InplaceDiv;
1335
 
} break;
1336
 
./
1337
 
 
1338
 
AssignmentOperator: T_REMAINDER_EQ ;
1339
 
/.
1340
 
case $rule_number: {
1341
 
  sym(1).ival = QSOperator::InplaceMod;
1342
 
} break;
1343
 
./
1344
 
 
1345
 
AssignmentOperator: T_PLUS_EQ ;
1346
 
/.
1347
 
case $rule_number: {
1348
 
  sym(1).ival = QSOperator::InplaceAdd;
1349
 
} break;
1350
 
./
1351
 
 
1352
 
AssignmentOperator: T_MINUS_EQ ;
1353
 
/.
1354
 
case $rule_number: {
1355
 
  sym(1).ival = QSOperator::InplaceSub;
1356
 
} break;
1357
 
./
1358
 
 
1359
 
AssignmentOperator: T_LT_LT_EQ ;
1360
 
/.
1361
 
case $rule_number: {
1362
 
  sym(1).ival = QSOperator::InplaceLeftShift;
1363
 
} break;
1364
 
./
1365
 
 
1366
 
AssignmentOperator: T_GT_GT_EQ ;
1367
 
/.
1368
 
case $rule_number: {
1369
 
  sym(1).ival = QSOperator::InplaceRightShift;
1370
 
} break;
1371
 
./
1372
 
 
1373
 
AssignmentOperator: T_GT_GT_GT_EQ ;
1374
 
/.
1375
 
case $rule_number: {
1376
 
  sym(1).ival = QSOperator::InplaceURightShift;
1377
 
} break;
1378
 
./
1379
 
 
1380
 
AssignmentOperator: T_AND_EQ ;
1381
 
/.
1382
 
case $rule_number: {
1383
 
  sym(1).ival = QSOperator::InplaceAnd;
1384
 
} break;
1385
 
./
1386
 
 
1387
 
AssignmentOperator: T_XOR_EQ ;
1388
 
/.
1389
 
case $rule_number: {
1390
 
  sym(1).ival = QSOperator::InplaceXor;
1391
 
} break;
1392
 
./
1393
 
 
1394
 
AssignmentOperator: T_OR_EQ ;
1395
 
/.
1396
 
case $rule_number: {
1397
 
  sym(1).ival = QSOperator::InplaceOr;
1398
 
} break;
1399
 
./
1400
 
 
1401
 
Expression: AssignmentExpression ;
1402
 
 
1403
 
Expression: Expression T_COMMA AssignmentExpression ;
1404
 
/.
1405
 
case $rule_number: {
1406
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
1407
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1408
 
} break;
1409
 
./
1410
 
 
1411
 
ExpressionOpt: ;
1412
 
/.
1413
 
case $rule_number: {
1414
 
  sym(1).Node = 0;
1415
 
} break;
1416
 
./
1417
 
 
1418
 
ExpressionOpt: Expression ;
1419
 
 
1420
 
ExpressionNotIn: AssignmentExpressionNotIn ;
1421
 
 
1422
 
ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ;
1423
 
/.
1424
 
case $rule_number: {
1425
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
1426
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1427
 
} break;
1428
 
./
1429
 
 
1430
 
ExpressionNotInOpt: ;
1431
 
/.
1432
 
case $rule_number: {
1433
 
  sym(1).Node = 0;
1434
 
} break;
1435
 
./
1436
 
 
1437
 
ExpressionNotInOpt: ExpressionNotIn ;
1438
 
 
1439
 
Statement: Block ;
1440
 
Statement: VariableStatement ;
1441
 
Statement: EmptyStatement ;
1442
 
Statement: ExpressionStatement ;
1443
 
Statement: IfStatement ;
1444
 
Statement: IterationStatement ;
1445
 
Statement: ContinueStatement ;
1446
 
Statement: BreakStatement ;
1447
 
Statement: ReturnStatement ;
1448
 
Statement: WithStatement ;
1449
 
Statement: LabelledStatement ;
1450
 
Statement: SwitchStatement ;
1451
 
Statement: ThrowStatement ;
1452
 
Statement: TryStatement ;
1453
 
Statement: DebuggerStatement ;
1454
 
 
1455
 
 
1456
 
Block: T_LBRACE StatementListOpt T_RBRACE ;
1457
 
/.
1458
 
case $rule_number: {
1459
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Block> (driver->nodePool(), sym(2).StatementList);
1460
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1461
 
} break;
1462
 
./
1463
 
 
1464
 
StatementList: Statement ;
1465
 
/.
1466
 
case $rule_number: {
1467
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StatementList> (driver->nodePool(), sym(1).Statement);
1468
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1469
 
} break;
1470
 
./
1471
 
 
1472
 
StatementList: StatementList Statement ;
1473
 
/.
1474
 
case $rule_number: {
1475
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement);
1476
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1477
 
} break;
1478
 
./
1479
 
 
1480
 
StatementListOpt: ;
1481
 
/.
1482
 
case $rule_number: {
1483
 
  sym(1).Node = 0;
1484
 
} break;
1485
 
./
1486
 
 
1487
 
StatementListOpt: StatementList ;
1488
 
/.
1489
 
case $rule_number: {
1490
 
  sym(1).Node = sym(1).StatementList->finish ();
1491
 
} break;
1492
 
./
1493
 
 
1494
 
VariableStatement: VariableDeclarationKind VariableDeclarationList T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1495
 
VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ;
1496
 
/.
1497
 
case $rule_number: {
1498
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableStatement> (driver->nodePool(), sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
1499
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1500
 
} break;
1501
 
./
1502
 
 
1503
 
VariableDeclarationKind: T_CONST ;
1504
 
/.
1505
 
case $rule_number: {
1506
 
  sym(1).ival = T_CONST;
1507
 
} break;
1508
 
./
1509
 
 
1510
 
VariableDeclarationKind: T_VAR ;
1511
 
/.
1512
 
case $rule_number: {
1513
 
  sym(1).ival = T_VAR;
1514
 
} break;
1515
 
./
1516
 
 
1517
 
VariableDeclarationList: VariableDeclaration ;
1518
 
/.
1519
 
case $rule_number: {
1520
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
1521
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1522
 
} break;
1523
 
./
1524
 
 
1525
 
VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ;
1526
 
/.
1527
 
case $rule_number: {
1528
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
1529
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1530
 
} break;
1531
 
./
1532
 
 
1533
 
VariableDeclarationListNotIn: VariableDeclarationNotIn ;
1534
 
/.
1535
 
case $rule_number: {
1536
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
1537
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1538
 
} break;
1539
 
./
1540
 
 
1541
 
VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ;
1542
 
/.
1543
 
case $rule_number: {
1544
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
1545
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1546
 
} break;
1547
 
./
1548
 
 
1549
 
VariableDeclaration: T_IDENTIFIER InitialiserOpt ;
1550
 
/.
1551
 
case $rule_number: {
1552
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
1553
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1554
 
} break;
1555
 
./
1556
 
 
1557
 
VariableDeclarationNotIn: T_IDENTIFIER InitialiserNotInOpt ;
1558
 
/.
1559
 
case $rule_number: {
1560
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
1561
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1562
 
} break;
1563
 
./
1564
 
 
1565
 
Initialiser: T_EQ AssignmentExpression ;
1566
 
/.
1567
 
case $rule_number: {
1568
 
  sym(1) = sym(2);
1569
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1570
 
} break;
1571
 
./
1572
 
 
1573
 
InitialiserOpt: ;
1574
 
/.
1575
 
case $rule_number: {
1576
 
  sym(1).Node = 0;
1577
 
} break;
1578
 
./
1579
 
 
1580
 
InitialiserOpt: Initialiser ;
1581
 
 
1582
 
InitialiserNotIn: T_EQ AssignmentExpressionNotIn ;
1583
 
/.
1584
 
case $rule_number: {
1585
 
  sym(1) = sym(2);
1586
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1587
 
} break;
1588
 
./
1589
 
 
1590
 
InitialiserNotInOpt: ;
1591
 
/.
1592
 
case $rule_number: {
1593
 
  sym(1).Node = 0;
1594
 
} break;
1595
 
./
1596
 
 
1597
 
InitialiserNotInOpt: InitialiserNotIn ;
1598
 
 
1599
 
EmptyStatement: T_SEMICOLON ;
1600
 
/.
1601
 
case $rule_number: {
1602
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::EmptyStatement> (driver->nodePool());
1603
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1604
 
} break;
1605
 
./
1606
 
 
1607
 
ExpressionStatement: Expression T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1608
 
ExpressionStatement: Expression T_SEMICOLON ;
1609
 
/.
1610
 
case $rule_number: {
1611
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression);
1612
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1613
 
} break;
1614
 
./
1615
 
 
1616
 
IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ;
1617
 
/.
1618
 
case $rule_number: {
1619
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement);
1620
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(7));
1621
 
} break;
1622
 
./
1623
 
 
1624
 
IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ;
1625
 
/.
1626
 
case $rule_number: {
1627
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
1628
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1629
 
} break;
1630
 
./
1631
 
 
1632
 
 
1633
 
IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1634
 
IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ;
1635
 
/.
1636
 
case $rule_number: {
1637
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression);
1638
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(7));
1639
 
} break;
1640
 
./
1641
 
 
1642
 
IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ;
1643
 
/.
1644
 
case $rule_number: {
1645
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
1646
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1647
 
} break;
1648
 
./
1649
 
 
1650
 
IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
1651
 
/.
1652
 
case $rule_number: {
1653
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ForStatement> (driver->nodePool(), sym(3).Expression, sym(5).Expression, sym(7).Expression, sym(9).Statement);
1654
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(9));
1655
 
} break;
1656
 
./
1657
 
 
1658
 
IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
1659
 
/.
1660
 
case $rule_number: {
1661
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::LocalForStatement> (driver->nodePool(), sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression, sym(8).Expression, sym(10).Statement);
1662
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(10));
1663
 
} break;
1664
 
./
1665
 
 
1666
 
IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ;
1667
 
/.
1668
 
case $rule_number: {
1669
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ForEachStatement> (driver->nodePool(), sym(3).Expression, sym(5).Expression, sym(7).Statement);
1670
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(7));
1671
 
} break;
1672
 
./
1673
 
 
1674
 
IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ;
1675
 
/.
1676
 
case $rule_number: {
1677
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::LocalForEachStatement> (driver->nodePool(), sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
1678
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(8));
1679
 
} break;
1680
 
./
1681
 
 
1682
 
ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1683
 
ContinueStatement: T_CONTINUE T_SEMICOLON ;
1684
 
/.
1685
 
case $rule_number: {
1686
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ContinueStatement> (driver->nodePool());
1687
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1688
 
} break;
1689
 
./
1690
 
 
1691
 
ContinueStatement: T_CONTINUE T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1692
 
ContinueStatement: T_CONTINUE T_IDENTIFIER T_SEMICOLON ;
1693
 
/.
1694
 
case $rule_number: {
1695
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ContinueStatement> (driver->nodePool(), sym(2).sval);
1696
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1697
 
} break;
1698
 
./
1699
 
 
1700
 
BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1701
 
BreakStatement: T_BREAK T_SEMICOLON ;
1702
 
/.
1703
 
case $rule_number: {
1704
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BreakStatement> (driver->nodePool());
1705
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1706
 
} break;
1707
 
./
1708
 
 
1709
 
BreakStatement: T_BREAK T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1710
 
BreakStatement: T_BREAK T_IDENTIFIER T_SEMICOLON ;
1711
 
/.
1712
 
case $rule_number: {
1713
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BreakStatement> (driver->nodePool(), sym(2).sval);
1714
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1715
 
} break;
1716
 
./
1717
 
 
1718
 
ReturnStatement: T_RETURN ExpressionOpt T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1719
 
ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ;
1720
 
/.
1721
 
case $rule_number: {
1722
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ReturnStatement> (driver->nodePool(), sym(2).Expression);
1723
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1724
 
} break;
1725
 
./
1726
 
 
1727
 
WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ;
1728
 
/.
1729
 
case $rule_number: {
1730
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
1731
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1732
 
} break;
1733
 
./
1734
 
 
1735
 
SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ;
1736
 
/.
1737
 
case $rule_number: {
1738
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock);
1739
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1740
 
} break;
1741
 
./
1742
 
 
1743
 
CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ;
1744
 
/.
1745
 
case $rule_number: {
1746
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses);
1747
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1748
 
} break;
1749
 
./
1750
 
 
1751
 
CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ;
1752
 
/.
1753
 
case $rule_number: {
1754
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
1755
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1756
 
} break;
1757
 
./
1758
 
 
1759
 
CaseClauses: CaseClause ;
1760
 
/.
1761
 
case $rule_number: {
1762
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause);
1763
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1764
 
} break;
1765
 
./
1766
 
 
1767
 
CaseClauses: CaseClauses CaseClause ;
1768
 
/.
1769
 
case $rule_number: {
1770
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause);
1771
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1772
 
} break;
1773
 
./
1774
 
 
1775
 
CaseClausesOpt: ;
1776
 
/.
1777
 
case $rule_number: {
1778
 
  sym(1).Node = 0;
1779
 
} break;
1780
 
./
1781
 
 
1782
 
CaseClausesOpt: CaseClauses ;
1783
 
/.
1784
 
case $rule_number: {
1785
 
  sym(1).Node = sym(1).CaseClauses->finish ();
1786
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1787
 
} break;
1788
 
./
1789
 
 
1790
 
CaseClause: T_CASE Expression T_COLON StatementListOpt ;
1791
 
/.
1792
 
case $rule_number: {
1793
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList);
1794
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
1795
 
} break;
1796
 
./
1797
 
 
1798
 
DefaultClause: T_DEFAULT T_COLON StatementListOpt ;
1799
 
/.
1800
 
case $rule_number: {
1801
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DefaultClause> (driver->nodePool(), sym(3).StatementList);
1802
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1803
 
} break;
1804
 
./
1805
 
 
1806
 
LabelledStatement: T_IDENTIFIER T_COLON Statement ;
1807
 
/.
1808
 
case $rule_number: {
1809
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement);
1810
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1811
 
} break;
1812
 
./
1813
 
 
1814
 
ThrowStatement: T_THROW Expression T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
1815
 
ThrowStatement: T_THROW Expression T_SEMICOLON ;
1816
 
/.
1817
 
case $rule_number: {
1818
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ThrowStatement> (driver->nodePool(), sym(2).Expression);
1819
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1820
 
} break;
1821
 
./
1822
 
 
1823
 
TryStatement: T_TRY Block Catch ;
1824
 
/.
1825
 
case $rule_number: {
1826
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch);
1827
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1828
 
} break;
1829
 
./
1830
 
 
1831
 
TryStatement: T_TRY Block Finally ;
1832
 
/.
1833
 
case $rule_number: {
1834
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally);
1835
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1836
 
} break;
1837
 
./
1838
 
 
1839
 
TryStatement: T_TRY Block Catch Finally ;
1840
 
/.
1841
 
case $rule_number: {
1842
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally);
1843
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
1844
 
} break;
1845
 
./
1846
 
 
1847
 
Catch: T_CATCH T_LPAREN T_IDENTIFIER T_RPAREN Block ;
1848
 
/.
1849
 
case $rule_number: {
1850
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Statement);
1851
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1852
 
} break;
1853
 
./
1854
 
 
1855
 
Finally: T_FINALLY Block ;
1856
 
/.
1857
 
case $rule_number: {
1858
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Finally> (driver->nodePool(), sym(2).Statement);
1859
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1860
 
} break;
1861
 
./
1862
 
 
1863
 
DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
1864
 
DebuggerStatement: T_DEBUGGER T_SEMICOLON ;
1865
 
/.
1866
 
case $rule_number: {
1867
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DebuggerStatement> (driver->nodePool());
1868
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1869
 
} break;
1870
 
./
1871
 
 
1872
 
FunctionDeclaration: T_FUNCTION T_IDENTIFIER T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
1873
 
/.
1874
 
case $rule_number: {
1875
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
1876
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(8));
1877
 
} break;
1878
 
./
1879
 
 
1880
 
FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
1881
 
/.
1882
 
case $rule_number: {
1883
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
1884
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(8));
1885
 
} break;
1886
 
./
1887
 
 
1888
 
FormalParameterList: T_IDENTIFIER ;
1889
 
/.
1890
 
case $rule_number: {
1891
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FormalParameterList> (driver->nodePool(), sym(1).sval);
1892
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1893
 
} break;
1894
 
./
1895
 
 
1896
 
FormalParameterList: FormalParameterList T_COMMA T_IDENTIFIER ;
1897
 
/.
1898
 
case $rule_number: {
1899
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval);
1900
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1901
 
} break;
1902
 
./
1903
 
 
1904
 
FormalParameterListOpt: ;
1905
 
/.
1906
 
case $rule_number: {
1907
 
  sym(1).Node = 0;
1908
 
} break;
1909
 
./
1910
 
 
1911
 
FormalParameterListOpt: FormalParameterList ;
1912
 
/.
1913
 
case $rule_number: {
1914
 
  sym(1).Node = sym(1).FormalParameterList->finish ();
1915
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1916
 
} break;
1917
 
./
1918
 
 
1919
 
FunctionBodyOpt: ;
1920
 
/.
1921
 
case $rule_number: {
1922
 
  sym(1).Node = 0;
1923
 
} break;
1924
 
./
1925
 
 
1926
 
FunctionBodyOpt: FunctionBody ;
1927
 
 
1928
 
FunctionBody: SourceElements ;
1929
 
/.
1930
 
case $rule_number: {
1931
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ());
1932
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1933
 
} break;
1934
 
./
1935
 
 
1936
 
Program: SourceElements ;
1937
 
/.
1938
 
case $rule_number: {
1939
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ());
1940
 
  driver->changeAbstractSyntaxTree(sym(1).Node);
1941
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1942
 
} break;
1943
 
./
1944
 
 
1945
 
SourceElements: SourceElement ;
1946
 
/.
1947
 
case $rule_number: {
1948
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::SourceElements> (driver->nodePool(), sym(1).SourceElement);
1949
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1950
 
} break;
1951
 
./
1952
 
 
1953
 
SourceElements: SourceElements SourceElement ;
1954
 
/.
1955
 
case $rule_number: {
1956
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement);
1957
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1958
 
} break;
1959
 
./
1960
 
 
1961
 
SourceElement: Statement ;
1962
 
/.
1963
 
case $rule_number: {
1964
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement);
1965
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1966
 
} break;
1967
 
./
1968
 
 
1969
 
SourceElement: FunctionDeclaration ;
1970
 
/.
1971
 
case $rule_number: {
1972
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration);
1973
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1974
 
} break;
1975
 
./
1976
 
 
1977
 
IdentifierOpt: ;
1978
 
/.
1979
 
case $rule_number: {
1980
 
  sym(1).sval = 0;
1981
 
} break;
1982
 
./
1983
 
 
1984
 
IdentifierOpt: T_IDENTIFIER ;
1985
 
 
1986
 
PropertyNameAndValueListOpt: ;
1987
 
/.
1988
 
case $rule_number: {
1989
 
  sym(1).Node = 0;
1990
 
} break;
1991
 
./
1992
 
 
1993
 
PropertyNameAndValueListOpt: PropertyNameAndValueList ;
1994
 
 
1995
 
/.
1996
 
          } // switch
1997
 
 
1998
 
          state_stack [tos] = nt_action (act, lhs [r] - TERMINAL_COUNT);
1999
 
 
2000
 
          if (rhs[r] > 1) {
2001
 
              location_stack[tos - 1].endLine = location_stack[tos + rhs[r] - 2].endLine;
2002
 
              location_stack[tos - 1].endColumn = location_stack[tos + rhs[r] - 2].endColumn;
2003
 
              location_stack[tos] = location_stack[tos + rhs[r] - 1];
2004
 
          }
2005
 
        }
2006
 
 
2007
 
      else
2008
 
        {
2009
 
          if (saved_yytoken == -1 && automatic (driver, yytoken) && t_action (state, T_AUTOMATIC_SEMICOLON) > 0)
2010
 
            {
2011
 
              saved_yytoken = yytoken;
2012
 
              yytoken = T_SEMICOLON;
2013
 
              continue;
2014
 
            }
2015
 
 
2016
 
          else if ((state == INITIAL_STATE) && (yytoken == 0)) {
2017
 
              // accept empty input
2018
 
              yytoken = T_SEMICOLON;
2019
 
              continue;
2020
 
          }
2021
 
 
2022
 
          int ers = state;
2023
 
          int shifts = 0;
2024
 
          int reduces = 0;
2025
 
          int expected_tokens [3];
2026
 
          for (int tk = 0; tk < TERMINAL_COUNT; ++tk)
2027
 
            {
2028
 
              int k = t_action (ers, tk);
2029
 
 
2030
 
              if (! k)
2031
 
                continue;
2032
 
              else if (k < 0)
2033
 
                ++reduces;
2034
 
              else if (spell [tk])
2035
 
                {
2036
 
                  if (shifts < 3)
2037
 
                    expected_tokens [shifts] = tk;
2038
 
                  ++shifts;
2039
 
                }
2040
 
            }
2041
 
 
2042
 
          error_message.clear ();
2043
 
          if (shifts && shifts < 3)
2044
 
            {
2045
 
              bool first = true;
2046
 
 
2047
 
              for (int s = 0; s < shifts; ++s)
2048
 
                {
2049
 
                  if (first)
2050
 
                    error_message += QLatin1String ("Expected ");
2051
 
                  else
2052
 
                    error_message += QLatin1String (", ");
2053
 
 
2054
 
                  first = false;
2055
 
                  error_message += QLatin1String("`");
2056
 
                  error_message += QLatin1String (spell [expected_tokens [s]]);
2057
 
                  error_message += QLatin1String("'");
2058
 
                }
2059
 
            }
2060
 
 
2061
 
          if (error_message.isEmpty())
2062
 
              error_message = lexer->errorMessage();
2063
 
 
2064
 
          error_lineno = lexer->startLineNo();
2065
 
          error_column = lexer->startColumnNo();
2066
 
 
2067
 
          return false;
2068
 
        }
2069
 
    }
2070
 
 
2071
 
    return false;
2072
 
}
2073
 
 
2074
 
QT_END_NAMESPACE
2075
 
 
2076
 
#endif // QT_NO_SCRIPT
2077
 
./
2078
 
/:
2079
 
QT_END_NAMESPACE
2080
 
 
2081
 
#endif // QT_NO_SCRIPT
2082
 
 
2083
 
#endif // QSCRIPTPARSER_P_H
2084
 
:/