← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/script/qscriptparser.cpp

  • 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/qscriptparser.cpp
1
 
// This file was generated by qlalr - DO NOT EDIT!
2
 
 
3
 
/****************************************************************************
4
 
**
5
 
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
6
 
** Contact: Nokia Corporation (qt-info@nokia.com)
7
 
**
8
 
** This file is part of the QtScript module of the Qt Toolkit.
9
 
**
10
 
** $QT_BEGIN_LICENSE:LGPL$
11
 
** Commercial Usage
12
 
** Licensees holding valid Qt Commercial licenses may use this file in
13
 
** accordance with the Qt Commercial License Agreement provided with the
14
 
** Software or, alternatively, in accordance with the terms contained in
15
 
** a written agreement between you and Nokia.
16
 
**
17
 
** GNU Lesser General Public License Usage
18
 
** Alternatively, this file may be used under the terms of the GNU Lesser
19
 
** General Public License version 2.1 as published by the Free Software
20
 
** Foundation and appearing in the file LICENSE.LGPL included in the
21
 
** packaging of this file.  Please review the following information to
22
 
** ensure the GNU Lesser General Public License version 2.1 requirements
23
 
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24
 
**
25
 
** In addition, as a special exception, Nokia gives you certain
26
 
** additional rights. These rights are described in the Nokia Qt LGPL
27
 
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
28
 
** package.
29
 
**
30
 
** GNU General Public License Usage
31
 
** Alternatively, this file may be used under the terms of the GNU
32
 
** General Public License version 3.0 as published by the Free Software
33
 
** Foundation and appearing in the file LICENSE.GPL included in the
34
 
** packaging of this file.  Please review the following information to
35
 
** ensure the GNU General Public License version 3.0 requirements will be
36
 
** met: http://www.gnu.org/copyleft/gpl.html.
37
 
**
38
 
** If you are unsure which license is appropriate for your use, please
39
 
** contact the sales department at http://www.qtsoftware.com/contact.
40
 
** $QT_END_LICENSE$
41
 
**
42
 
****************************************************************************/
43
 
 
44
 
#include <QtCore/QtDebug>
45
 
 
46
 
#ifndef QT_NO_SCRIPT
47
 
 
48
 
#include <string.h>
49
 
 
50
 
#include "qscriptengine.h"
51
 
#include "qscriptengine_p.h"
52
 
#include "qscriptvalueimpl_p.h"
53
 
#include "qscriptcontext_p.h"
54
 
#include "qscriptmember_p.h"
55
 
#include "qscriptobject_p.h"
56
 
#include "qscriptlexer_p.h"
57
 
#include "qscriptast_p.h"
58
 
#include "qscriptnodepool_p.h"
59
 
 
60
 
#define Q_SCRIPT_UPDATE_POSITION(node, startloc, endloc) do { \
61
 
    node->startLine = startloc.startLine; \
62
 
    node->startColumn = startloc.startColumn; \
63
 
    node->endLine = endloc.endLine; \
64
 
    node->endColumn = endloc.endColumn; \
65
 
} while (0)
66
 
 
67
 
 
68
 
 
69
 
#include "qscriptparser_p.h"
70
 
 
71
 
//
72
 
// This file is automatically generated from qscript.g.
73
 
// Changes will be lost.
74
 
//
75
 
 
76
 
QT_BEGIN_NAMESPACE
77
 
 
78
 
inline static bool automatic(QScriptEnginePrivate *driver, int token)
79
 
{
80
 
    return token == QScriptGrammar::T_RBRACE
81
 
        || token == 0
82
 
        || driver->lexer()->prevTerminator();
83
 
}
84
 
 
85
 
 
86
 
QScriptParser::QScriptParser():
87
 
    tos(0),
88
 
    stack_size(0),
89
 
    sym_stack(0),
90
 
    state_stack(0),
91
 
    location_stack(0),
92
 
    error_lineno(0),
93
 
    error_column(0)
94
 
{
95
 
}
96
 
 
97
 
QScriptParser::~QScriptParser()
98
 
{
99
 
    if (stack_size) {
100
 
        qFree(sym_stack);
101
 
        qFree(state_stack);
102
 
        qFree(location_stack);
103
 
    }
104
 
}
105
 
 
106
 
static inline QScriptParser::Location location(QScript::Lexer *lexer)
107
 
{
108
 
    QScriptParser::Location loc;
109
 
    loc.startLine = lexer->startLineNo();
110
 
    loc.startColumn = lexer->startColumnNo();
111
 
    loc.endLine = lexer->endLineNo();
112
 
    loc.endColumn = lexer->endColumnNo();
113
 
    return loc;
114
 
}
115
 
 
116
 
bool QScriptParser::parse(QScriptEnginePrivate *driver)
117
 
{
118
 
  const int INITIAL_STATE = 0;
119
 
  QScript::Lexer *lexer = driver->lexer();
120
 
 
121
 
  int yytoken = -1;
122
 
  int saved_yytoken = -1;
123
 
 
124
 
  reallocateStack();
125
 
 
126
 
  tos = 0;
127
 
  state_stack[++tos] = INITIAL_STATE;
128
 
 
129
 
  while (true)
130
 
    {
131
 
      const int state = state_stack [tos];
132
 
      if (yytoken == -1 && - TERMINAL_COUNT != action_index [state])
133
 
        {
134
 
          if (saved_yytoken == -1)
135
 
            {
136
 
              yytoken = lexer->lex();
137
 
              location_stack [tos] = location(lexer);
138
 
            }
139
 
          else
140
 
            {
141
 
              yytoken = saved_yytoken;
142
 
              saved_yytoken = -1;
143
 
            }
144
 
        }
145
 
 
146
 
      int act = t_action (state, yytoken);
147
 
 
148
 
      if (act == ACCEPT_STATE)
149
 
        return true;
150
 
 
151
 
      else if (act > 0)
152
 
        {
153
 
          if (++tos == stack_size)
154
 
            reallocateStack();
155
 
 
156
 
          sym_stack [tos].dval = lexer->dval ();
157
 
          state_stack [tos] = act;
158
 
          location_stack [tos] = location(lexer);
159
 
          yytoken = -1;
160
 
        }
161
 
 
162
 
      else if (act < 0)
163
 
        {
164
 
          int r = - act - 1;
165
 
 
166
 
          tos -= rhs [r];
167
 
          act = state_stack [tos++];
168
 
 
169
 
          switch (r) {
170
 
 
171
 
case 0: {
172
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ThisExpression> (driver->nodePool());
173
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
174
 
} break;
175
 
 
176
 
case 1: {
177
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);
178
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
179
 
} break;
180
 
 
181
 
case 2: {
182
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NullExpression> (driver->nodePool());
183
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
184
 
} break;
185
 
 
186
 
case 3: {
187
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TrueLiteral> (driver->nodePool());
188
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
189
 
} break;
190
 
 
191
 
case 4: {
192
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FalseLiteral> (driver->nodePool());
193
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
194
 
} break;
195
 
 
196
 
case 5: {
197
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NumericLiteral> (driver->nodePool(), sym(1).dval);
198
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
199
 
} break;
200
 
 
201
 
case 6: {
202
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StringLiteral> (driver->nodePool(), sym(1).sval);
203
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
204
 
} break;
205
 
 
206
 
case 7: {
207
 
  bool rx = lexer->scanRegExp(QScript::Lexer::NoPrefix);
208
 
  if (!rx) {
209
 
      error_message = lexer->errorMessage();
210
 
      error_lineno = lexer->startLineNo();
211
 
      error_column = lexer->startColumnNo();
212
 
      return false;
213
 
  }
214
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
215
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
216
 
} break;
217
 
 
218
 
case 8: {
219
 
  bool rx = lexer->scanRegExp(QScript::Lexer::EqualPrefix);
220
 
  if (!rx) {
221
 
      error_message = lexer->errorMessage();
222
 
      error_lineno = lexer->startLineNo();
223
 
      error_column = lexer->startColumnNo();
224
 
      return false;
225
 
  }
226
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
227
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
228
 
} break;
229
 
 
230
 
case 9: {
231
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision);
232
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
233
 
} break;
234
 
 
235
 
case 10: {
236
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ());
237
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
238
 
} break;
239
 
 
240
 
case 11: {
241
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (), sym(4).Elision);
242
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
243
 
} break;
244
 
 
245
 
case 12: {
246
 
  if (sym(2).Node)
247
 
    sym(1).Node = QScript::makeAstNode<QScript::AST::ObjectLiteral> (driver->nodePool(), sym(2).PropertyNameAndValueList->finish ());
248
 
  else
249
 
    sym(1).Node = QScript::makeAstNode<QScript::AST::ObjectLiteral> (driver->nodePool());
250
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
251
 
} break;
252
 
 
253
 
case 13: {
254
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ObjectLiteral> (driver->nodePool(), sym(2).PropertyNameAndValueList->finish ());
255
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
256
 
} break;
257
 
 
258
 
case 14: {
259
 
  sym(1) = sym(2);
260
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
261
 
} break;
262
 
 
263
 
case 15: {
264
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ElementList> (driver->nodePool(), sym(1).Elision, sym(2).Expression);
265
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
266
 
} break;
267
 
 
268
 
case 16: {
269
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision, sym(4).Expression);
270
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
271
 
} break;
272
 
 
273
 
case 17: {
274
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Elision> (driver->nodePool());
275
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
276
 
} break;
277
 
 
278
 
case 18: {
279
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Elision> (driver->nodePool(), sym(1).Elision);
280
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
281
 
} break;
282
 
 
283
 
case 19: {
284
 
  sym(1).Node = 0;
285
 
} break;
286
 
 
287
 
case 20: {
288
 
  sym(1).Elision = sym(1).Elision->finish ();
289
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
290
 
} break;
291
 
 
292
 
case 21: {
293
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PropertyNameAndValueList> (driver->nodePool(), sym(1).PropertyName, sym(3).Expression);
294
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
295
 
} break;
296
 
 
297
 
case 22: {
298
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PropertyNameAndValueList> (driver->nodePool(), sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
299
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
300
 
} break;
301
 
 
302
 
case 23: {
303
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
304
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
305
 
} break;
306
 
 
307
 
case 24: {
308
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval);
309
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
310
 
} break;
311
 
 
312
 
case 25: {
313
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval);
314
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
315
 
} break;
316
 
 
317
 
case 26: {
318
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
319
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
320
 
} break;
321
 
 
322
 
case 27:
323
 
 
324
 
case 28:
325
 
 
326
 
case 29:
327
 
 
328
 
case 30:
329
 
 
330
 
case 31:
331
 
 
332
 
case 32:
333
 
 
334
 
case 33:
335
 
 
336
 
case 34:
337
 
 
338
 
case 35:
339
 
 
340
 
case 36:
341
 
 
342
 
case 37:
343
 
 
344
 
case 38:
345
 
 
346
 
case 39:
347
 
 
348
 
case 40:
349
 
 
350
 
case 41:
351
 
 
352
 
case 42:
353
 
 
354
 
case 43:
355
 
 
356
 
case 44:
357
 
 
358
 
case 45:
359
 
 
360
 
case 46:
361
 
 
362
 
case 47:
363
 
 
364
 
case 48:
365
 
 
366
 
case 49:
367
 
 
368
 
case 50:
369
 
 
370
 
case 51:
371
 
 
372
 
case 52:
373
 
 
374
 
case 53:
375
 
 
376
 
case 54:
377
 
 
378
 
case 55:
379
 
 
380
 
case 56:
381
 
 
382
 
case 57:
383
 
{
384
 
  sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
385
 
} break;
386
 
 
387
 
case 62: {
388
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
389
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
390
 
} break;
391
 
 
392
 
case 63: {
393
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
394
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
395
 
} break;
396
 
 
397
 
case 64: {
398
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(3).ArgumentList);
399
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
400
 
} break;
401
 
 
402
 
case 66: {
403
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NewExpression> (driver->nodePool(), sym(2).Expression);
404
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
405
 
} break;
406
 
 
407
 
case 67: {
408
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(2).ArgumentList);
409
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
410
 
} break;
411
 
 
412
 
case 68: {
413
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(2).ArgumentList);
414
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
415
 
} break;
416
 
 
417
 
case 69: {
418
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
419
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
420
 
} break;
421
 
 
422
 
case 70: {
423
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
424
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
425
 
} break;
426
 
 
427
 
case 71: {
428
 
  sym(1).Node = 0;
429
 
} break;
430
 
 
431
 
case 72: {
432
 
  sym(1).Node = sym(2).ArgumentList->finish ();
433
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
434
 
} break;
435
 
 
436
 
case 73: {
437
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArgumentList> (driver->nodePool(), sym(1).Expression);
438
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
439
 
} break;
440
 
 
441
 
case 74: {
442
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression);
443
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
444
 
} break;
445
 
 
446
 
case 78: {
447
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression);
448
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
449
 
} break;
450
 
 
451
 
case 79: {
452
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression);
453
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
454
 
} break;
455
 
 
456
 
case 81: {
457
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DeleteExpression> (driver->nodePool(), sym(2).Expression);
458
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
459
 
} break;
460
 
 
461
 
case 82: {
462
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VoidExpression> (driver->nodePool(), sym(2).Expression);
463
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
464
 
} break;
465
 
 
466
 
case 83: {
467
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression);
468
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
469
 
} break;
470
 
 
471
 
case 84: {
472
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression);
473
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
474
 
} break;
475
 
 
476
 
case 85: {
477
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression);
478
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
479
 
} break;
480
 
 
481
 
case 86: {
482
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression);
483
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
484
 
} break;
485
 
 
486
 
case 87: {
487
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression);
488
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
489
 
} break;
490
 
 
491
 
case 88: {
492
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TildeExpression> (driver->nodePool(), sym(2).Expression);
493
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
494
 
} break;
495
 
 
496
 
case 89: {
497
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::NotExpression> (driver->nodePool(), sym(2).Expression);
498
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
499
 
} break;
500
 
 
501
 
case 91: {
502
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Mul, sym(3).Expression);
503
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
504
 
} break;
505
 
 
506
 
case 92: {
507
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Div, sym(3).Expression);
508
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
509
 
} break;
510
 
 
511
 
case 93: {
512
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Mod, sym(3).Expression);
513
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
514
 
} break;
515
 
 
516
 
case 95: {
517
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Add, sym(3).Expression);
518
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
519
 
} break;
520
 
 
521
 
case 96: {
522
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Sub, sym(3).Expression);
523
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
524
 
} break;
525
 
 
526
 
case 98: {
527
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::LShift, sym(3).Expression);
528
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
529
 
} break;
530
 
 
531
 
case 99: {
532
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::RShift, sym(3).Expression);
533
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
534
 
} break;
535
 
 
536
 
case 100: {
537
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::URShift, sym(3).Expression);
538
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
539
 
} break;
540
 
 
541
 
case 102: {
542
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Lt, sym(3).Expression);
543
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
544
 
} break;
545
 
 
546
 
case 103: {
547
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Gt, sym(3).Expression);
548
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
549
 
} break;
550
 
 
551
 
case 104: {
552
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Le, sym(3).Expression);
553
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
554
 
} break;
555
 
 
556
 
case 105: {
557
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Ge, sym(3).Expression);
558
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
559
 
} break;
560
 
 
561
 
case 106: {
562
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::InstanceOf, sym(3).Expression);
563
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
564
 
} break;
565
 
 
566
 
case 107: {
567
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::In, sym(3).Expression);
568
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
569
 
} break;
570
 
 
571
 
case 109: {
572
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Lt, sym(3).Expression);
573
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
574
 
} break;
575
 
 
576
 
case 110: {
577
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Gt, sym(3).Expression);
578
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
579
 
} break;
580
 
 
581
 
case 111: {
582
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Le, sym(3).Expression);
583
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
584
 
} break;
585
 
 
586
 
case 112: {
587
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Ge, sym(3).Expression);
588
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
589
 
} break;
590
 
 
591
 
case 113: {
592
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::InstanceOf, sym(3).Expression);
593
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
594
 
} break;
595
 
 
596
 
case 115: {
597
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Equal, sym(3).Expression);
598
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
599
 
} break;
600
 
 
601
 
case 116: {
602
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::NotEqual, sym(3).Expression);
603
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
604
 
} break;
605
 
 
606
 
case 117: {
607
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictEqual, sym(3).Expression);
608
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
609
 
} break;
610
 
 
611
 
case 118: {
612
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictNotEqual, sym(3).Expression);
613
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
614
 
} break;
615
 
 
616
 
case 120: {
617
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Equal, sym(3).Expression);
618
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
619
 
} break;
620
 
 
621
 
case 121: {
622
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::NotEqual, sym(3).Expression);
623
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
624
 
} break;
625
 
 
626
 
case 122: {
627
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictEqual, sym(3).Expression);
628
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
629
 
} break;
630
 
 
631
 
case 123: {
632
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::StrictNotEqual, sym(3).Expression);
633
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
634
 
} break;
635
 
 
636
 
case 125: {
637
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitAnd, sym(3).Expression);
638
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
639
 
} break;
640
 
 
641
 
case 127: {
642
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitAnd, sym(3).Expression);
643
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
644
 
} break;
645
 
 
646
 
case 129: {
647
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitXor, sym(3).Expression);
648
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
649
 
} break;
650
 
 
651
 
case 131: {
652
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitXor, sym(3).Expression);
653
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
654
 
} break;
655
 
 
656
 
case 133: {
657
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitOr, sym(3).Expression);
658
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
659
 
} break;
660
 
 
661
 
case 135: {
662
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::BitOr, sym(3).Expression);
663
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
664
 
} break;
665
 
 
666
 
case 137: {
667
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::And, sym(3).Expression);
668
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
669
 
} break;
670
 
 
671
 
case 139: {
672
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::And, sym(3).Expression);
673
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
674
 
} break;
675
 
 
676
 
case 141: {
677
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Or, sym(3).Expression);
678
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
679
 
} break;
680
 
 
681
 
case 143: {
682
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, QSOperator::Or, sym(3).Expression);
683
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
684
 
} break;
685
 
 
686
 
case 145: {
687
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression, sym(5).Expression);
688
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
689
 
} break;
690
 
 
691
 
case 147: {
692
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression, sym(5).Expression);
693
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
694
 
} break;
695
 
 
696
 
case 149: {
697
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, sym(2).ival, sym(3).Expression);
698
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
699
 
} break;
700
 
 
701
 
case 151: {
702
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, sym(2).ival, sym(3).Expression);
703
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
704
 
} break;
705
 
 
706
 
case 152: {
707
 
  sym(1).ival = QSOperator::Assign;
708
 
} break;
709
 
 
710
 
case 153: {
711
 
  sym(1).ival = QSOperator::InplaceMul;
712
 
} break;
713
 
 
714
 
case 154: {
715
 
  sym(1).ival = QSOperator::InplaceDiv;
716
 
} break;
717
 
 
718
 
case 155: {
719
 
  sym(1).ival = QSOperator::InplaceMod;
720
 
} break;
721
 
 
722
 
case 156: {
723
 
  sym(1).ival = QSOperator::InplaceAdd;
724
 
} break;
725
 
 
726
 
case 157: {
727
 
  sym(1).ival = QSOperator::InplaceSub;
728
 
} break;
729
 
 
730
 
case 158: {
731
 
  sym(1).ival = QSOperator::InplaceLeftShift;
732
 
} break;
733
 
 
734
 
case 159: {
735
 
  sym(1).ival = QSOperator::InplaceRightShift;
736
 
} break;
737
 
 
738
 
case 160: {
739
 
  sym(1).ival = QSOperator::InplaceURightShift;
740
 
} break;
741
 
 
742
 
case 161: {
743
 
  sym(1).ival = QSOperator::InplaceAnd;
744
 
} break;
745
 
 
746
 
case 162: {
747
 
  sym(1).ival = QSOperator::InplaceXor;
748
 
} break;
749
 
 
750
 
case 163: {
751
 
  sym(1).ival = QSOperator::InplaceOr;
752
 
} break;
753
 
 
754
 
case 165: {
755
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
756
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
757
 
} break;
758
 
 
759
 
case 166: {
760
 
  sym(1).Node = 0;
761
 
} break;
762
 
 
763
 
case 169: {
764
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
765
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
766
 
} break;
767
 
 
768
 
case 170: {
769
 
  sym(1).Node = 0;
770
 
} break;
771
 
 
772
 
case 187: {
773
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Block> (driver->nodePool(), sym(2).StatementList);
774
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
775
 
} break;
776
 
 
777
 
case 188: {
778
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StatementList> (driver->nodePool(), sym(1).Statement);
779
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
780
 
} break;
781
 
 
782
 
case 189: {
783
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement);
784
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
785
 
} break;
786
 
 
787
 
case 190: {
788
 
  sym(1).Node = 0;
789
 
} break;
790
 
 
791
 
case 191: {
792
 
  sym(1).Node = sym(1).StatementList->finish ();
793
 
} break;
794
 
 
795
 
case 193: {
796
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableStatement> (driver->nodePool(), sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
797
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
798
 
} break;
799
 
 
800
 
case 194: {
801
 
  sym(1).ival = T_CONST;
802
 
} break;
803
 
 
804
 
case 195: {
805
 
  sym(1).ival = T_VAR;
806
 
} break;
807
 
 
808
 
case 196: {
809
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
810
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
811
 
} break;
812
 
 
813
 
case 197: {
814
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
815
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
816
 
} break;
817
 
 
818
 
case 198: {
819
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
820
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
821
 
} break;
822
 
 
823
 
case 199: {
824
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
825
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
826
 
} break;
827
 
 
828
 
case 200: {
829
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
830
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
831
 
} break;
832
 
 
833
 
case 201: {
834
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
835
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
836
 
} break;
837
 
 
838
 
case 202: {
839
 
  sym(1) = sym(2);
840
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
841
 
} break;
842
 
 
843
 
case 203: {
844
 
  sym(1).Node = 0;
845
 
} break;
846
 
 
847
 
case 205: {
848
 
  sym(1) = sym(2);
849
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
850
 
} break;
851
 
 
852
 
case 206: {
853
 
  sym(1).Node = 0;
854
 
} break;
855
 
 
856
 
case 208: {
857
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::EmptyStatement> (driver->nodePool());
858
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
859
 
} break;
860
 
 
861
 
case 210: {
862
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression);
863
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
864
 
} break;
865
 
 
866
 
case 211: {
867
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement);
868
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(7));
869
 
} break;
870
 
 
871
 
case 212: {
872
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
873
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
874
 
} break;
875
 
 
876
 
case 214: {
877
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression);
878
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(7));
879
 
} break;
880
 
 
881
 
case 215: {
882
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
883
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
884
 
} break;
885
 
 
886
 
case 216: {
887
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ForStatement> (driver->nodePool(), sym(3).Expression, sym(5).Expression, sym(7).Expression, sym(9).Statement);
888
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(9));
889
 
} break;
890
 
 
891
 
case 217: {
892
 
  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);
893
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(10));
894
 
} break;
895
 
 
896
 
case 218: {
897
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ForEachStatement> (driver->nodePool(), sym(3).Expression, sym(5).Expression, sym(7).Statement);
898
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(7));
899
 
} break;
900
 
 
901
 
case 219: {
902
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::LocalForEachStatement> (driver->nodePool(), sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
903
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(8));
904
 
} break;
905
 
 
906
 
case 221: {
907
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ContinueStatement> (driver->nodePool());
908
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
909
 
} break;
910
 
 
911
 
case 223: {
912
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ContinueStatement> (driver->nodePool(), sym(2).sval);
913
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
914
 
} break;
915
 
 
916
 
case 225: {
917
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BreakStatement> (driver->nodePool());
918
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
919
 
} break;
920
 
 
921
 
case 227: {
922
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::BreakStatement> (driver->nodePool(), sym(2).sval);
923
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
924
 
} break;
925
 
 
926
 
case 229: {
927
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ReturnStatement> (driver->nodePool(), sym(2).Expression);
928
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
929
 
} break;
930
 
 
931
 
case 230: {
932
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
933
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
934
 
} break;
935
 
 
936
 
case 231: {
937
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock);
938
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
939
 
} break;
940
 
 
941
 
case 232: {
942
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses);
943
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
944
 
} break;
945
 
 
946
 
case 233: {
947
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
948
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
949
 
} break;
950
 
 
951
 
case 234: {
952
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause);
953
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
954
 
} break;
955
 
 
956
 
case 235: {
957
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause);
958
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
959
 
} break;
960
 
 
961
 
case 236: {
962
 
  sym(1).Node = 0;
963
 
} break;
964
 
 
965
 
case 237: {
966
 
  sym(1).Node = sym(1).CaseClauses->finish ();
967
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
968
 
} break;
969
 
 
970
 
case 238: {
971
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList);
972
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
973
 
} break;
974
 
 
975
 
case 239: {
976
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DefaultClause> (driver->nodePool(), sym(3).StatementList);
977
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
978
 
} break;
979
 
 
980
 
case 240: {
981
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement);
982
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
983
 
} break;
984
 
 
985
 
case 242: {
986
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::ThrowStatement> (driver->nodePool(), sym(2).Expression);
987
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
988
 
} break;
989
 
 
990
 
case 243: {
991
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch);
992
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
993
 
} break;
994
 
 
995
 
case 244: {
996
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally);
997
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
998
 
} break;
999
 
 
1000
 
case 245: {
1001
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally);
1002
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(4));
1003
 
} break;
1004
 
 
1005
 
case 246: {
1006
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Statement);
1007
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(5));
1008
 
} break;
1009
 
 
1010
 
case 247: {
1011
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Finally> (driver->nodePool(), sym(2).Statement);
1012
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1013
 
} break;
1014
 
 
1015
 
case 249: {
1016
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::DebuggerStatement> (driver->nodePool());
1017
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1018
 
} break;
1019
 
 
1020
 
case 250: {
1021
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
1022
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(8));
1023
 
} break;
1024
 
 
1025
 
case 251: {
1026
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
1027
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(8));
1028
 
} break;
1029
 
 
1030
 
case 252: {
1031
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FormalParameterList> (driver->nodePool(), sym(1).sval);
1032
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1033
 
} break;
1034
 
 
1035
 
case 253: {
1036
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval);
1037
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(3));
1038
 
} break;
1039
 
 
1040
 
case 254: {
1041
 
  sym(1).Node = 0;
1042
 
} break;
1043
 
 
1044
 
case 255: {
1045
 
  sym(1).Node = sym(1).FormalParameterList->finish ();
1046
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1047
 
} break;
1048
 
 
1049
 
case 256: {
1050
 
  sym(1).Node = 0;
1051
 
} break;
1052
 
 
1053
 
case 258: {
1054
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ());
1055
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1056
 
} break;
1057
 
 
1058
 
case 259: {
1059
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ());
1060
 
  driver->changeAbstractSyntaxTree(sym(1).Node);
1061
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1062
 
} break;
1063
 
 
1064
 
case 260: {
1065
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::SourceElements> (driver->nodePool(), sym(1).SourceElement);
1066
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1067
 
} break;
1068
 
 
1069
 
case 261: {
1070
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement);
1071
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(2));
1072
 
} break;
1073
 
 
1074
 
case 262: {
1075
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement);
1076
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1077
 
} break;
1078
 
 
1079
 
case 263: {
1080
 
  sym(1).Node = QScript::makeAstNode<QScript::AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration);
1081
 
  Q_SCRIPT_UPDATE_POSITION(sym(1).Node, loc(1), loc(1));
1082
 
} break;
1083
 
 
1084
 
case 264: {
1085
 
  sym(1).sval = 0;
1086
 
} break;
1087
 
 
1088
 
case 266: {
1089
 
  sym(1).Node = 0;
1090
 
} break;
1091
 
 
1092
 
          } // switch
1093
 
 
1094
 
          state_stack [tos] = nt_action (act, lhs [r] - TERMINAL_COUNT);
1095
 
 
1096
 
          if (rhs[r] > 1) {
1097
 
              location_stack[tos - 1].endLine = location_stack[tos + rhs[r] - 2].endLine;
1098
 
              location_stack[tos - 1].endColumn = location_stack[tos + rhs[r] - 2].endColumn;
1099
 
              location_stack[tos] = location_stack[tos + rhs[r] - 1];
1100
 
          }
1101
 
        }
1102
 
 
1103
 
      else
1104
 
        {
1105
 
          if (saved_yytoken == -1 && automatic (driver, yytoken) && t_action (state, T_AUTOMATIC_SEMICOLON) > 0)
1106
 
            {
1107
 
              saved_yytoken = yytoken;
1108
 
              yytoken = T_SEMICOLON;
1109
 
              continue;
1110
 
            }
1111
 
 
1112
 
          else if ((state == INITIAL_STATE) && (yytoken == 0)) {
1113
 
              // accept empty input
1114
 
              yytoken = T_SEMICOLON;
1115
 
              continue;
1116
 
          }
1117
 
 
1118
 
          int ers = state;
1119
 
          int shifts = 0;
1120
 
          int reduces = 0;
1121
 
          int expected_tokens [3];
1122
 
          for (int tk = 0; tk < TERMINAL_COUNT; ++tk)
1123
 
            {
1124
 
              int k = t_action (ers, tk);
1125
 
 
1126
 
              if (! k)
1127
 
                continue;
1128
 
              else if (k < 0)
1129
 
                ++reduces;
1130
 
              else if (spell [tk])
1131
 
                {
1132
 
                  if (shifts < 3)
1133
 
                    expected_tokens [shifts] = tk;
1134
 
                  ++shifts;
1135
 
                }
1136
 
            }
1137
 
 
1138
 
          error_message.clear ();
1139
 
          if (shifts && shifts < 3)
1140
 
            {
1141
 
              bool first = true;
1142
 
 
1143
 
              for (int s = 0; s < shifts; ++s)
1144
 
                {
1145
 
                  if (first)
1146
 
                    error_message += QLatin1String ("Expected ");
1147
 
                  else
1148
 
                    error_message += QLatin1String (", ");
1149
 
 
1150
 
                  first = false;
1151
 
                  error_message += QLatin1String("`");
1152
 
                  error_message += QLatin1String (spell [expected_tokens [s]]);
1153
 
                  error_message += QLatin1String("'");
1154
 
                }
1155
 
            }
1156
 
 
1157
 
          if (error_message.isEmpty())
1158
 
              error_message = lexer->errorMessage();
1159
 
 
1160
 
          error_lineno = lexer->startLineNo();
1161
 
          error_column = lexer->startColumnNo();
1162
 
 
1163
 
          return false;
1164
 
        }
1165
 
    }
1166
 
 
1167
 
    return false;
1168
 
}
1169
 
 
1170
 
QT_END_NAMESPACE
1171
 
 
1172
 
#endif // QT_NO_SCRIPT