src/script/parser/qscript.g

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