src/declarative/qml/parser/qdeclarativejsparser.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtDeclarative module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtCore/QtDebug>
  43 #include <QtGui/QGuiApplication>
  44
  45 #include <string.h>
  46
  47 #include "qdeclarativejsengine_p.h"
  48 #include "qdeclarativejslexer_p.h"
  49 #include "qdeclarativejsast_p.h"
  50 #include "qdeclarativejsmemorypool_p.h"
  51
  52
  53
  54 #include "qdeclarativejsparser_p.h"
  55 #include <QVarLengthArray>
  56
  57 //
  58 // This file is automatically generated from qmljs.g.
  59 // Changes will be lost.
  60 //
  61
  62 using namespace QDeclarativeJS;
  63
  64 QT_QML_BEGIN_NAMESPACE
  65
  66 void Parser::reallocateStack()
  67 {
  68     if (! stack_size)
  69         stack_size = 128;
  70     else
  71         stack_size <<= 1;
  72
  73     sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
  74     state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
  75     location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
  76     string_stack = reinterpret_cast<QStringRef*> (qRealloc(string_stack, stack_size * sizeof(QStringRef)));
  77 }
  78
  79 inline static bool automatic(Engine *driver, int token)
  80 {
  81     return token == QDeclarativeJSGrammar::T_RBRACE
  82         || token == 0
  83         || driver->lexer()->prevTerminator();
  84 }
  85
  86
  87 Parser::Parser(Engine *engine):
  88     driver(engine),
  89     pool(engine->pool()),
  90     tos(0),
  91     stack_size(0),
  92     sym_stack(0),
  93     state_stack(0),
  94     location_stack(0),
  95     string_stack(0),
  96     first_token(0),
  97     last_token(0)
  98 {
  99 }
 100
 101 Parser::~Parser()
 102 {
 103     if (stack_size) {
 104         qFree(sym_stack);
 105         qFree(state_stack);
 106         qFree(location_stack);
 107         qFree(string_stack);
 108     }
 109 }
 110
 111 static inline AST::SourceLocation location(Lexer *lexer)
 112 {
 113     AST::SourceLocation loc;
 114     loc.offset = lexer->tokenOffset();
 115     loc.length = lexer->tokenLength();
 116     loc.startLine = lexer->tokenStartLine();
 117     loc.startColumn = lexer->tokenStartColumn();
 118     return loc;
 119 }
 120
 121 AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
 122 {
 123     QVarLengthArray<QStringRef, 4> nameIds;
 124     QVarLengthArray<AST::SourceLocation, 4> locations;
 125
 126     AST::ExpressionNode *it = expr;
 127     while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
 128         nameIds.append(m->name);
 129         locations.append(m->identifierToken);
 130         it = m->base;
 131     }
 132
 133     if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
 134         AST::UiQualifiedId *q = new (pool) AST::UiQualifiedId(idExpr->name);
 135         q->identifierToken = idExpr->identifierToken;
 136
 137         AST::UiQualifiedId *currentId = q;
 138         for (int i = nameIds.size() - 1; i != -1; --i) {
 139             currentId = new (pool) AST::UiQualifiedId(currentId, nameIds[i]);
 140             currentId->identifierToken = locations[i];
 141         }
 142
 143         return currentId->finish();
 144     }
 145
 146     return 0;
 147 }
 148
 149 bool Parser::parse(int startToken)
 150 {
 151     Lexer *lexer = driver->lexer();
 152     bool hadErrors = false;
 153     int yytoken = -1;
 154     int action = 0;
 155
 156     token_buffer[0].token = startToken;
 157     first_token = &token_buffer[0];
 158     last_token = &token_buffer[1];
 159
 160     tos = -1;
 161     program = 0;
 162
 163     do {
 164         if (++tos == stack_size)
 165             reallocateStack();
 166
 167         state_stack[tos] = action;
 168
 169     _Lcheck_token:
 170         if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
 171             yyprevlloc = yylloc;
 172
 173             if (first_token == last_token) {
 174                 yytoken = lexer->lex();
 175                 yylval = lexer->tokenValue();
 176                 yytokenspell = lexer->tokenSpell();
 177                 yylloc = location(lexer);
 178             } else {
 179                 yytoken = first_token->token;
 180                 yylval = first_token->dval;
 181                 yytokenspell = first_token->spell;
 182                 yylloc = first_token->loc;
 183                 ++first_token;
 184             }
 185         }
 186
 187         action = t_action(action, yytoken);
 188         if (action > 0) {
 189             if (action != ACCEPT_STATE) {
 190                 yytoken = -1;
 191                 sym(1).dval = yylval;
 192                 stringRef(1) = yytokenspell;
 193                 loc(1) = yylloc;
 194             } else {
 195               --tos;
 196               return ! hadErrors;
 197             }
 198         } else if (action < 0) {
 199           const int r = -action - 1;
 200           tos -= rhs[r];
 201
 202           switch (r) {
 203
 204 case 0: {
 205   sym(1).Node = sym(2).Node;
 206   program = sym(1).Node;
 207 } break;
 208
 209 case 1: {
 210   sym(1).Node = sym(2).Node;
 211   program = sym(1).Node;
 212 } break;
 213
 214 case 2: {
 215   sym(1).Node = sym(2).Node;
 216   program = sym(1).Node;
 217 } break;
 218
 219 case 3: {
 220   sym(1).Node = sym(2).Node;
 221   program = sym(1).Node;
 222 } break;
 223
 224 case 4: {
 225   sym(1).Node = sym(2).Node;
 226   program = sym(1).Node;
 227 } break;
 228
 229 case 5: {
 230   sym(1).Node = sym(2).Node;
 231   program = sym(1).Node;
 232 } break;
 233
 234 case 6: {
 235   sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiImportList,
 236         sym(2).UiObjectMemberList->finish());
 237 } break;
 238
 239 case 8: {
 240     sym(1).Node = sym(1).UiImportList->finish();
 241 } break;
 242
 243 case 9: {
 244     sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImport);
 245 } break;
 246
 247 case 10: {
 248     sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImportList, sym(2).UiImport);
 249 } break;
 250
 251 case 13: {
 252     sym(1).UiImport->semicolonToken = loc(2);
 253 } break;
 254
 255 case 15: {
 256     sym(1).UiImport->versionToken = loc(2);
 257     sym(1).UiImport->semicolonToken = loc(3);
 258 } break;
 259
 260 case 17: {
 261     sym(1).UiImport->versionToken = loc(2);
 262     sym(1).UiImport->asToken = loc(3);
 263     sym(1).UiImport->importIdToken = loc(4);
 264     sym(1).UiImport->importId = stringRef(4);
 265     sym(1).UiImport->semicolonToken = loc(5);
 266 } break;
 267
 268 case 19: {
 269     sym(1).UiImport->asToken = loc(2);
 270     sym(1).UiImport->importIdToken = loc(3);
 271     sym(1).UiImport->importId = stringRef(3);
 272     sym(1).UiImport->semicolonToken = loc(4);
 273 } break;
 274
 275 case 20: {
 276     AST::UiImport *node = 0;
 277
 278     if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
 279         node = new (pool) AST::UiImport(importIdLiteral->value);
 280         node->fileNameToken = loc(2);
 281     } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
 282         node = new (pool) AST::UiImport(qualifiedId);
 283         node->fileNameToken = loc(2);
 284     }
 285
 286     sym(1).Node = node;
 287
 288     if (node) {
 289         node->importToken = loc(1);
 290     } else {
 291        diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
 292          QLatin1String("Expected a qualified name id or a string literal")));
 293
 294         return false; // ### remove me
 295     }
 296 } break;
 297
 298 case 21: {
 299     sym(1).Node = 0;
 300 } break;
 301
 302 case 22: {
 303     sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
 304 } break;
 305
 306 case 23: {
 307     sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
 308 } break;
 309
 310 case 24: {
 311     AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(
 312         sym(1).UiObjectMemberList, sym(2).UiObjectMember);
 313     sym(1).Node = node;
 314 } break;
 315
 316 case 25: {
 317     sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
 318 } break;
 319
 320 case 26: {
 321     AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(
 322         sym(1).UiArrayMemberList, sym(3).UiObjectMember);
 323     node->commaToken = loc(2);
 324     sym(1).Node = node;
 325 } break;
 326
 327 case 27: {
 328     AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
 329     node->lbraceToken = loc(1);
 330     node->rbraceToken = loc(2);
 331     sym(1).Node = node;
 332 }   break;
 333
 334 case 28: {
 335     AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish());
 336     node->lbraceToken = loc(1);
 337     node->rbraceToken = loc(3);
 338     sym(1).Node = node;
 339 }   break;
 340
 341 case 29: {
 342     AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId,
 343         sym(2).UiObjectInitializer);
 344     sym(1).Node = node;
 345 }   break;
 346
 347 case 31: {
 348     AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(
 349         sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
 350     node->colonToken = loc(2);
 351     node->lbracketToken = loc(3);
 352     node->rbracketToken = loc(5);
 353     sym(1).Node = node;
 354 }   break;
 355
 356 case 32: {
 357     AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
 358       sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
 359     node->colonToken = loc(2);
 360     sym(1).Node = node;
 361 } break;
 362
 363 case 33: {
 364     AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
 365       sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
 366     node->colonToken = loc(2);
 367     node->hasOnToken = true;
 368     sym(1).Node = node;
 369 } break;
 370
 371 case 38:
 372 {
 373     AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(
 374         sym(1).UiQualifiedId, sym(3).Statement);
 375     node->colonToken = loc(2);
 376     sym(1).Node = node;
 377 }   break;
 378
 379 case 42: {
 380   sym(1).Node = 0;
 381 } break;
 382
 383 case 43: {
 384   sym(1).Node = sym(1).UiParameterList->finish ();
 385 } break;
 386
 387 case 44: {
 388   AST::UiParameterList *node = new (pool) AST::UiParameterList(stringRef(1), stringRef(2));
 389   node->identifierToken = loc(2);
 390   sym(1).Node = node;
 391 } break;
 392
 393 case 45: {
 394   AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, stringRef(3), stringRef(4));
 395   node->commaToken = loc(2);
 396   node->identifierToken = loc(4);
 397   sym(1).Node = node;
 398 } break;
 399
 400 case 47: {
 401     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
 402     node->type = AST::UiPublicMember::Signal;
 403     node->propertyToken = loc(1);
 404     node->typeToken = loc(2);
 405     node->identifierToken = loc(2);
 406     node->parameters = sym(4).UiParameterList;
 407     node->semicolonToken = loc(6);
 408     sym(1).Node = node;
 409 }   break;
 410
 411 case 49: {
 412     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
 413     node->type = AST::UiPublicMember::Signal;
 414     node->propertyToken = loc(1);
 415     node->typeToken = loc(2);
 416     node->identifierToken = loc(2);
 417     node->semicolonToken = loc(3);
 418     sym(1).Node = node;
 419 }   break;
 420
 421 case 51: {
 422     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
 423     node->typeModifier = stringRef(2);
 424     node->propertyToken = loc(1);
 425     node->typeModifierToken = loc(2);
 426     node->typeToken = loc(4);
 427     node->identifierToken = loc(6);
 428     node->semicolonToken = loc(7);
 429     sym(1).Node = node;
 430 }   break;
 431
 432 case 53: {
 433     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
 434     node->propertyToken = loc(1);
 435     node->typeToken = loc(2);
 436     node->identifierToken = loc(3);
 437     node->semicolonToken = loc(4);
 438     sym(1).Node = node;
 439 }   break;
 440
 441 case 55: {
 442     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4));
 443     node->isDefaultMember = true;
 444     node->defaultToken = loc(1);
 445     node->propertyToken = loc(2);
 446     node->typeToken = loc(3);
 447     node->identifierToken = loc(4);
 448     node->semicolonToken = loc(5);
 449     sym(1).Node = node;
 450 }   break;
 451
 452 case 56: {
 453     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3),
 454         sym(5).Statement);
 455     node->propertyToken = loc(1);
 456     node->typeToken = loc(2);
 457     node->identifierToken = loc(3);
 458     node->colonToken = loc(4);
 459     sym(1).Node = node;
 460 }   break;
 461
 462 case 57: {
 463     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
 464         sym(6).Statement);
 465     node->isReadonlyMember = true;
 466     node->readonlyToken = loc(1);
 467     node->propertyToken = loc(2);
 468     node->typeToken = loc(3);
 469     node->identifierToken = loc(4);
 470     node->colonToken = loc(5);
 471     sym(1).Node = node;
 472 }   break;
 473
 474 case 58: {
 475     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
 476         sym(6).Statement);
 477     node->isDefaultMember = true;
 478     node->defaultToken = loc(1);
 479     node->propertyToken = loc(2);
 480     node->typeToken = loc(3);
 481     node->identifierToken = loc(4);
 482     node->colonToken = loc(5);
 483     sym(1).Node = node;
 484 }   break;
 485
 486 case 59: {
 487     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
 488     node->typeModifier = stringRef(2);
 489     node->propertyToken = loc(1);
 490     node->typeModifierToken = loc(2);
 491     node->typeToken = loc(4);
 492     node->identifierToken = loc(6);
 493     node->semicolonToken = loc(7); // insert a fake ';' before ':'
 494
 495     AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(6));
 496     propertyName->identifierToken = loc(6);
 497     propertyName->next = 0;
 498
 499     AST::UiArrayBinding *binding = new (pool) AST::UiArrayBinding(
 500         propertyName, sym(9).UiArrayMemberList->finish());
 501     binding->colonToken = loc(7);
 502     binding->lbracketToken = loc(8);
 503     binding->rbracketToken = loc(10);
 504
 505     node->binding = binding;
 506
 507     sym(1).Node = node;
 508 }   break;
 509
 510 case 60: {
 511     AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
 512     node->propertyToken = loc(1);
 513     node->typeToken = loc(2);
 514     node->identifierToken = loc(3);
 515     node->semicolonToken = loc(4); // insert a fake ';' before ':'
 516
 517     AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(3));
 518     propertyName->identifierToken = loc(3);
 519     propertyName->next = 0;
 520
 521     AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
 522       propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
 523     binding->colonToken = loc(4);
 524
 525     node->binding = binding;
 526
 527     sym(1).Node = node;
 528 }   break;
 529
 530 case 61: {
 531     sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
 532 }   break;
 533
 534 case 62: {
 535     sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
 536 }   break;
 537
 538 case 68: {
 539   AST::ThisExpression *node = new (pool) AST::ThisExpression();
 540   node->thisToken = loc(1);
 541   sym(1).Node = node;
 542 } break;
 543
 544 case 69: {
 545   AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
 546   node->identifierToken = loc(1);
 547   sym(1).Node = node;
 548 } break;
 549
 550 case 70: {
 551   AST::NullExpression *node = new (pool) AST::NullExpression();
 552   node->nullToken = loc(1);
 553   sym(1).Node = node;
 554 } break;
 555
 556 case 71: {
 557   AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
 558   node->trueToken = loc(1);
 559   sym(1).Node = node;
 560 } break;
 561
 562 case 72: {
 563   AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
 564   node->falseToken = loc(1);
 565   sym(1).Node = node;
 566 } break;
 567
 568 case 73: {
 569   AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
 570   node->literalToken = loc(1);
 571   sym(1).Node = node;
 572 } break;
 573 case 74:
 574 case 75: {
 575   AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
 576   node->literalToken = loc(1);
 577   sym(1).Node = node;
 578 } break;
 579
 580 case 76: {
 581   bool rx = lexer->scanRegExp(Lexer::NoPrefix);
 582   if (!rx) {
 583     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
 584     return false; // ### remove me
 585   }
 586
 587   loc(1).length = lexer->tokenLength();
 588
 589   AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
 590     driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
 591   node->literalToken = loc(1);
 592   sym(1).Node = node;
 593 } break;
 594
 595 case 77: {
 596   bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
 597   if (!rx) {
 598     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
 599     return false;
 600   }
 601
 602   loc(1).length = lexer->tokenLength();
 603
 604   AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
 605     driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
 606   node->literalToken = loc(1);
 607   sym(1).Node = node;
 608 } break;
 609
 610 case 78: {
 611   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral((AST::Elision *) 0);
 612   node->lbracketToken = loc(1);
 613   node->rbracketToken = loc(2);
 614   sym(1).Node = node;
 615 } break;
 616
 617 case 79: {
 618   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).Elision->finish());
 619   node->lbracketToken = loc(1);
 620   node->rbracketToken = loc(3);
 621   sym(1).Node = node;
 622 } break;
 623
 624 case 80: {
 625   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish ());
 626   node->lbracketToken = loc(1);
 627   node->rbracketToken = loc(3);
 628   sym(1).Node = node;
 629 } break;
 630
 631 case 81: {
 632   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
 633     (AST::Elision *) 0);
 634   node->lbracketToken = loc(1);
 635   node->commaToken = loc(3);
 636   node->rbracketToken = loc(4);
 637   sym(1).Node = node;
 638 } break;
 639
 640 case 82: {
 641   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
 642     sym(4).Elision->finish());
 643   node->lbracketToken = loc(1);
 644   node->commaToken = loc(3);
 645   node->rbracketToken = loc(5);
 646   sym(1).Node = node;
 647 } break;
 648
 649 case 83: {
 650   AST::ObjectLiteral *node = 0;
 651   if (sym(2).Node)
 652     node = new (pool) AST::ObjectLiteral(
 653         sym(2).PropertyNameAndValueList->finish ());
 654   else
 655     node = new (pool) AST::ObjectLiteral();
 656   node->lbraceToken = loc(1);
 657   node->rbraceToken = loc(3);
 658   sym(1).Node = node;
 659 } break;
 660
 661 case 84: {
 662   AST::ObjectLiteral *node = new (pool) AST::ObjectLiteral(
 663     sym(2).PropertyNameAndValueList->finish ());
 664   node->lbraceToken = loc(1);
 665   node->rbraceToken = loc(4);
 666   sym(1).Node = node;
 667 } break;
 668
 669 case 85: {
 670   AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression);
 671   node->lparenToken = loc(1);
 672   node->rparenToken = loc(3);
 673   sym(1).Node = node;
 674 } break;
 675
 676 case 86: {
 677   if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
 678     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken,
 679       QLatin1String("Ignored annotation")));
 680
 681     sym(1).Expression = mem->base;
 682   }
 683
 684   if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
 685     sym(1).UiQualifiedId = qualifiedId;
 686   } else {
 687     sym(1).UiQualifiedId = 0;
 688
 689     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
 690       QLatin1String("Expected a qualified name id")));
 691
 692     return false; // ### recover
 693   }
 694 } break;
 695
 696 case 87: {
 697   sym(1).Node = new (pool) AST::ElementList((AST::Elision *) 0, sym(1).Expression);
 698 } break;
 699
 700 case 88: {
 701   sym(1).Node = new (pool) AST::ElementList(sym(1).Elision->finish(), sym(2).Expression);
 702 } break;
 703
 704 case 89: {
 705   AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList,
 706     (AST::Elision *) 0, sym(3).Expression);
 707   node->commaToken = loc(2);
 708   sym(1).Node = node;
 709 } break;
 710
 711 case 90: {
 712   AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList, sym(3).Elision->finish(),
 713     sym(4).Expression);
 714   node->commaToken = loc(2);
 715   sym(1).Node = node;
 716 } break;
 717
 718 case 91: {
 719   AST::Elision *node = new (pool) AST::Elision();
 720   node->commaToken = loc(1);
 721   sym(1).Node = node;
 722 } break;
 723
 724 case 92: {
 725   AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
 726   node->commaToken = loc(2);
 727   sym(1).Node = node;
 728 } break;
 729
 730 case 93: {
 731   AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
 732       sym(1).PropertyName, sym(3).Expression);
 733   node->colonToken = loc(2);
 734   sym(1).Node = node;
 735 } break;
 736
 737 case 94: {
 738   AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
 739       sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
 740   node->commaToken = loc(2);
 741   node->colonToken = loc(4);
 742   sym(1).Node = node;
 743 } break;
 744
 745 case 95: {
 746   AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
 747   node->propertyNameToken = loc(1);
 748   sym(1).Node = node;
 749 } break;
 750 case 96:
 751 case 97: {
 752   AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
 753   node->propertyNameToken = loc(1);
 754   sym(1).Node = node;
 755 } break;
 756
 757 case 98: {
 758   AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
 759   node->propertyNameToken = loc(1);
 760   sym(1).Node = node;
 761 } break;
 762
 763 case 99: {
 764   AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
 765   node->propertyNameToken = loc(1);
 766   sym(1).Node = node;
 767 } break;
 768
 769 case 100: {
 770   AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
 771   node->propertyNameToken = loc(1);
 772   sym(1).Node = node;
 773 } break;
 774
 775 case 136: {
 776   AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
 777   node->lbracketToken = loc(2);
 778   node->rbracketToken = loc(4);
 779   sym(1).Node = node;
 780 } break;
 781
 782 case 137: {
 783   AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
 784   node->dotToken = loc(2);
 785   node->identifierToken = loc(3);
 786   sym(1).Node = node;
 787 } break;
 788
 789 case 138: {
 790   AST::NewMemberExpression *node = new (pool) AST::NewMemberExpression(sym(2).Expression, sym(4).ArgumentList);
 791   node->newToken = loc(1);
 792   node->lparenToken = loc(3);
 793   node->rparenToken = loc(5);
 794   sym(1).Node = node;
 795 } break;
 796
 797 case 140: {
 798   AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
 799   node->newToken = loc(1);
 800   sym(1).Node = node;
 801 } break;
 802
 803 case 141: {
 804   AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
 805   node->lparenToken = loc(2);
 806   node->rparenToken = loc(4);
 807   sym(1).Node = node;
 808 } break;
 809
 810 case 142: {
 811   AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
 812   node->lparenToken = loc(2);
 813   node->rparenToken = loc(4);
 814   sym(1).Node = node;
 815 } break;
 816
 817 case 143: {
 818   AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
 819   node->lbracketToken = loc(2);
 820   node->rbracketToken = loc(4);
 821   sym(1).Node = node;
 822 } break;
 823
 824 case 144: {
 825   AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
 826   node->dotToken = loc(2);
 827   node->identifierToken = loc(3);
 828   sym(1).Node = node;
 829 } break;
 830
 831 case 145: {
 832   sym(1).Node = 0;
 833 } break;
 834
 835 case 146: {
 836   sym(1).Node = sym(1).ArgumentList->finish();
 837 } break;
 838
 839 case 147: {
 840   sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
 841 } break;
 842
 843 case 148: {
 844   AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
 845   node->commaToken = loc(2);
 846   sym(1).Node = node;
 847 } break;
 848
 849 case 152: {
 850   AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
 851   node->incrementToken = loc(2);
 852   sym(1).Node = node;
 853 } break;
 854
 855 case 153: {
 856   AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
 857   node->decrementToken = loc(2);
 858   sym(1).Node = node;
 859 } break;
 860
 861 case 155: {
 862   AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
 863   node->deleteToken = loc(1);
 864   sym(1).Node = node;
 865 } break;
 866
 867 case 156: {
 868   AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
 869   node->voidToken = loc(1);
 870   sym(1).Node = node;
 871 } break;
 872
 873 case 157: {
 874   AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
 875   node->typeofToken = loc(1);
 876   sym(1).Node = node;
 877 } break;
 878
 879 case 158: {
 880   AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
 881   node->incrementToken = loc(1);
 882   sym(1).Node = node;
 883 } break;
 884
 885 case 159: {
 886   AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
 887   node->decrementToken = loc(1);
 888   sym(1).Node = node;
 889 } break;
 890
 891 case 160: {
 892   AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
 893   node->plusToken = loc(1);
 894   sym(1).Node = node;
 895 } break;
 896
 897 case 161: {
 898   AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
 899   node->minusToken = loc(1);
 900   sym(1).Node = node;
 901 } break;
 902
 903 case 162: {
 904   AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
 905   node->tildeToken = loc(1);
 906   sym(1).Node = node;
 907 } break;
 908
 909 case 163: {
 910   AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
 911   node->notToken = loc(1);
 912   sym(1).Node = node;
 913 } break;
 914
 915 case 165: {
 916   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 917     QSOperator::Mul, sym(3).Expression);
 918   node->operatorToken = loc(2);
 919   sym(1).Node = node;
 920 } break;
 921
 922 case 166: {
 923   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 924     QSOperator::Div, sym(3).Expression);
 925   node->operatorToken = loc(2);
 926   sym(1).Node = node;
 927 } break;
 928
 929 case 167: {
 930   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 931     QSOperator::Mod, sym(3).Expression);
 932   node->operatorToken = loc(2);
 933   sym(1).Node = node;
 934 } break;
 935
 936 case 169: {
 937   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 938     QSOperator::Add, sym(3).Expression);
 939   node->operatorToken = loc(2);
 940   sym(1).Node = node;
 941 } break;
 942
 943 case 170: {
 944   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 945     QSOperator::Sub, sym(3).Expression);
 946   node->operatorToken = loc(2);
 947   sym(1).Node = node;
 948 } break;
 949
 950 case 172: {
 951   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 952     QSOperator::LShift, sym(3).Expression);
 953   node->operatorToken = loc(2);
 954   sym(1).Node = node;
 955 } break;
 956
 957 case 173: {
 958   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 959     QSOperator::RShift, sym(3).Expression);
 960   node->operatorToken = loc(2);
 961   sym(1).Node = node;
 962 } break;
 963
 964 case 174: {
 965   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 966     QSOperator::URShift, sym(3).Expression);
 967   node->operatorToken = loc(2);
 968   sym(1).Node = node;
 969 } break;
 970
 971 case 176: {
 972   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 973     QSOperator::Lt, sym(3).Expression);
 974   node->operatorToken = loc(2);
 975   sym(1).Node = node;
 976 } break;
 977
 978 case 177: {
 979   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 980     QSOperator::Gt, sym(3).Expression);
 981   node->operatorToken = loc(2);
 982   sym(1).Node = node;
 983 } break;
 984
 985 case 178: {
 986   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 987     QSOperator::Le, sym(3).Expression);
 988   node->operatorToken = loc(2);
 989   sym(1).Node = node;
 990 } break;
 991
 992 case 179: {
 993   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 994     QSOperator::Ge, sym(3).Expression);
 995   node->operatorToken = loc(2);
 996   sym(1).Node = node;
 997 } break;
 998
 999 case 180: {
1000   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1001     QSOperator::InstanceOf, sym(3).Expression);
1002   node->operatorToken = loc(2);
1003   sym(1).Node = node;
1004 } break;
1005
1006 case 181: {
1007   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1008     QSOperator::In, sym(3).Expression);
1009   node->operatorToken = loc(2);
1010   sym(1).Node = node;
1011 } break;
1012
1013 case 183: {
1014   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1015     QSOperator::Lt, sym(3).Expression);
1016   node->operatorToken = loc(2);
1017   sym(1).Node = node;
1018 } break;
1019
1020 case 184: {
1021   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1022     QSOperator::Gt, sym(3).Expression);
1023   node->operatorToken = loc(2);
1024   sym(1).Node = node;
1025 } break;
1026
1027 case 185: {
1028   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1029     QSOperator::Le, sym(3).Expression);
1030   node->operatorToken = loc(2);
1031   sym(1).Node = node;
1032 } break;
1033
1034 case 186: {
1035   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1036    QSOperator::Ge, sym(3).Expression);
1037   node->operatorToken = loc(2);
1038   sym(1).Node = node;
1039 } break;
1040
1041 case 187: {
1042   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1043     QSOperator::InstanceOf, sym(3).Expression);
1044   node->operatorToken = loc(2);
1045   sym(1).Node = node;
1046 } break;
1047
1048 case 189: {
1049   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1050     QSOperator::Equal, sym(3).Expression);
1051   node->operatorToken = loc(2);
1052   sym(1).Node = node;
1053 } break;
1054
1055 case 190: {
1056   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1057     QSOperator::NotEqual, sym(3).Expression);
1058   node->operatorToken = loc(2);
1059   sym(1).Node = node;
1060 } break;
1061
1062 case 191: {
1063   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1064     QSOperator::StrictEqual, sym(3).Expression);
1065   node->operatorToken = loc(2);
1066   sym(1).Node = node;
1067 } break;
1068
1069 case 192: {
1070   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1071     QSOperator::StrictNotEqual, sym(3).Expression);
1072   node->operatorToken = loc(2);
1073   sym(1).Node = node;
1074 } break;
1075
1076 case 194: {
1077   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1078     QSOperator::Equal, sym(3).Expression);
1079   node->operatorToken = loc(2);
1080   sym(1).Node = node;
1081 } break;
1082
1083 case 195: {
1084   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1085     QSOperator::NotEqual, sym(3).Expression);
1086   node->operatorToken = loc(2);
1087   sym(1).Node = node;
1088 } break;
1089
1090 case 196: {
1091   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1092     QSOperator::StrictEqual, sym(3).Expression);
1093   node->operatorToken = loc(2);
1094   sym(1).Node = node;
1095 } break;
1096
1097 case 197: {
1098   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1099     QSOperator::StrictNotEqual, sym(3).Expression);
1100   node->operatorToken = loc(2);
1101   sym(1).Node = node;
1102 } break;
1103
1104 case 199: {
1105   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1106     QSOperator::BitAnd, sym(3).Expression);
1107   node->operatorToken = loc(2);
1108   sym(1).Node = node;
1109 } break;
1110
1111 case 201: {
1112   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1113     QSOperator::BitAnd, sym(3).Expression);
1114   node->operatorToken = loc(2);
1115   sym(1).Node = node;
1116 } break;
1117
1118 case 203: {
1119   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1120     QSOperator::BitXor, sym(3).Expression);
1121   node->operatorToken = loc(2);
1122   sym(1).Node = node;
1123 } break;
1124
1125 case 205: {
1126   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1127     QSOperator::BitXor, sym(3).Expression);
1128   node->operatorToken = loc(2);
1129   sym(1).Node = node;
1130 } break;
1131
1132 case 207: {
1133   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1134     QSOperator::BitOr, sym(3).Expression);
1135   node->operatorToken = loc(2);
1136   sym(1).Node = node;
1137 } break;
1138
1139 case 209: {
1140   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1141     QSOperator::BitOr, sym(3).Expression);
1142   node->operatorToken = loc(2);
1143   sym(1).Node = node;
1144 } break;
1145
1146 case 211: {
1147   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1148     QSOperator::And, sym(3).Expression);
1149   node->operatorToken = loc(2);
1150   sym(1).Node = node;
1151 } break;
1152
1153 case 213: {
1154   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1155     QSOperator::And, sym(3).Expression);
1156   node->operatorToken = loc(2);
1157   sym(1).Node = node;
1158 } break;
1159
1160 case 215: {
1161   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1162     QSOperator::Or, sym(3).Expression);
1163   node->operatorToken = loc(2);
1164   sym(1).Node = node;
1165 } break;
1166
1167 case 217: {
1168   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1169     QSOperator::Or, sym(3).Expression);
1170   node->operatorToken = loc(2);
1171   sym(1).Node = node;
1172 } break;
1173
1174 case 219: {
1175   AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
1176     sym(3).Expression, sym(5).Expression);
1177   node->questionToken = loc(2);
1178   node->colonToken = loc(4);
1179   sym(1).Node = node;
1180 } break;
1181
1182 case 221: {
1183   AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
1184     sym(3).Expression, sym(5).Expression);
1185   node->questionToken = loc(2);
1186   node->colonToken = loc(4);
1187   sym(1).Node = node;
1188 } break;
1189
1190 case 223: {
1191   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1192     sym(2).ival, sym(3).Expression);
1193   node->operatorToken = loc(2);
1194   sym(1).Node = node;
1195 } break;
1196
1197 case 225: {
1198   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1199     sym(2).ival, sym(3).Expression);
1200   node->operatorToken = loc(2);
1201   sym(1).Node = node;
1202 } break;
1203
1204 case 226: {
1205   sym(1).ival = QSOperator::Assign;
1206 } break;
1207
1208 case 227: {
1209   sym(1).ival = QSOperator::InplaceMul;
1210 } break;
1211
1212 case 228: {
1213   sym(1).ival = QSOperator::InplaceDiv;
1214 } break;
1215
1216 case 229: {
1217   sym(1).ival = QSOperator::InplaceMod;
1218 } break;
1219
1220 case 230: {
1221   sym(1).ival = QSOperator::InplaceAdd;
1222 } break;
1223
1224 case 231: {
1225   sym(1).ival = QSOperator::InplaceSub;
1226 } break;
1227
1228 case 232: {
1229   sym(1).ival = QSOperator::InplaceLeftShift;
1230 } break;
1231
1232 case 233: {
1233   sym(1).ival = QSOperator::InplaceRightShift;
1234 } break;
1235
1236 case 234: {
1237   sym(1).ival = QSOperator::InplaceURightShift;
1238 } break;
1239
1240 case 235: {
1241   sym(1).ival = QSOperator::InplaceAnd;
1242 } break;
1243
1244 case 236: {
1245   sym(1).ival = QSOperator::InplaceXor;
1246 } break;
1247
1248 case 237: {
1249   sym(1).ival = QSOperator::InplaceOr;
1250 } break;
1251
1252 case 239: {
1253   AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
1254   node->commaToken = loc(2);
1255   sym(1).Node = node;
1256 } break;
1257
1258 case 240: {
1259   sym(1).Node = 0;
1260 } break;
1261
1262 case 243: {
1263   AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
1264   node->commaToken = loc(2);
1265   sym(1).Node = node;
1266 } break;
1267
1268 case 244: {
1269   sym(1).Node = 0;
1270 } break;
1271
1272 case 261: {
1273   AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
1274   node->lbraceToken = loc(1);
1275   node->rbraceToken = loc(3);
1276   sym(1).Node = node;
1277 } break;
1278
1279 case 262: {
1280   sym(1).Node = new (pool) AST::StatementList(sym(1).Statement);
1281 } break;
1282
1283 case 263: {
1284   sym(1).Node = new (pool) AST::StatementList(sym(1).StatementList, sym(2).Statement);
1285 } break;
1286
1287 case 264: {
1288   sym(1).Node = 0;
1289 } break;
1290
1291 case 265: {
1292   sym(1).Node = sym(1).StatementList->finish ();
1293 } break;
1294
1295 case 267: {
1296   AST::VariableStatement *node = new (pool) AST::VariableStatement(
1297      sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
1298   node->declarationKindToken = loc(1);
1299   node->semicolonToken = loc(3);
1300   sym(1).Node = node;
1301 } break;
1302
1303 case 268: {
1304   sym(1).ival = T_CONST;
1305 } break;
1306
1307 case 269: {
1308   sym(1).ival = T_VAR;
1309 } break;
1310
1311 case 270: {
1312   sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
1313 } break;
1314
1315 case 271: {
1316   AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(
1317     sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
1318   node->commaToken = loc(2);
1319   sym(1).Node = node;
1320 } break;
1321
1322 case 272: {
1323   sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
1324 } break;
1325
1326 case 273: {
1327   sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
1328 } break;
1329
1330 case 274: {
1331   AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
1332   node->identifierToken = loc(1);
1333   sym(1).Node = node;
1334 } break;
1335
1336 case 275: {
1337   AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
1338   node->identifierToken = loc(1);
1339   sym(1).Node = node;
1340 } break;
1341
1342 case 276: {
1343   // ### TODO: AST for initializer
1344   sym(1) = sym(2);
1345 } break;
1346
1347 case 277: {
1348   sym(1).Node = 0;
1349 } break;
1350
1351 case 279: {
1352   // ### TODO: AST for initializer
1353   sym(1) = sym(2);
1354 } break;
1355
1356 case 280: {
1357   sym(1).Node = 0;
1358 } break;
1359
1360 case 282: {
1361   AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
1362   node->semicolonToken = loc(1);
1363   sym(1).Node = node;
1364 } break;
1365
1366 case 284: {
1367   AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
1368   node->semicolonToken = loc(2);
1369   sym(1).Node = node;
1370 } break;
1371
1372 case 285: {
1373   AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement, sym(7).Statement);
1374   node->ifToken = loc(1);
1375   node->lparenToken = loc(2);
1376   node->rparenToken = loc(4);
1377   node->elseToken = loc(6);
1378   sym(1).Node = node;
1379 } break;
1380
1381 case 286: {
1382   AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement);
1383   node->ifToken = loc(1);
1384   node->lparenToken = loc(2);
1385   node->rparenToken = loc(4);
1386   sym(1).Node = node;
1387 } break;
1388
1389 case 288: {
1390   AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression);
1391   node->doToken = loc(1);
1392   node->whileToken = loc(3);
1393   node->lparenToken = loc(4);
1394   node->rparenToken = loc(6);
1395   node->semicolonToken = loc(7);
1396   sym(1).Node = node;
1397 } break;
1398
1399 case 289: {
1400   AST::WhileStatement *node = new (pool) AST::WhileStatement(sym(3).Expression, sym(5).Statement);
1401   node->whileToken = loc(1);
1402   node->lparenToken = loc(2);
1403   node->rparenToken = loc(4);
1404   sym(1).Node = node;
1405 } break;
1406
1407 case 290: {
1408   AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression,
1409     sym(5).Expression, sym(7).Expression, sym(9).Statement);
1410   node->forToken = loc(1);
1411   node->lparenToken = loc(2);
1412   node->firstSemicolonToken = loc(4);
1413   node->secondSemicolonToken = loc(6);
1414   node->rparenToken = loc(8);
1415   sym(1).Node = node;
1416 } break;
1417
1418 case 291: {
1419   AST::LocalForStatement *node = new (pool) AST::LocalForStatement(
1420      sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
1421      sym(8).Expression, sym(10).Statement);
1422   node->forToken = loc(1);
1423   node->lparenToken = loc(2);
1424   node->varToken = loc(3);
1425   node->firstSemicolonToken = loc(5);
1426   node->secondSemicolonToken = loc(7);
1427   node->rparenToken = loc(9);
1428   sym(1).Node = node;
1429 } break;
1430
1431 case 292: {
1432   AST:: ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression,
1433     sym(5).Expression, sym(7).Statement);
1434   node->forToken = loc(1);
1435   node->lparenToken = loc(2);
1436   node->inToken = loc(4);
1437   node->rparenToken = loc(6);
1438   sym(1).Node = node;
1439 } break;
1440
1441 case 293: {
1442   AST::LocalForEachStatement *node = new (pool) AST::LocalForEachStatement(
1443     sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
1444   node->forToken = loc(1);
1445   node->lparenToken = loc(2);
1446   node->varToken = loc(3);
1447   node->inToken = loc(5);
1448   node->rparenToken = loc(7);
1449   sym(1).Node = node;
1450 } break;
1451
1452 case 295: {
1453   AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
1454   node->continueToken = loc(1);
1455   node->semicolonToken = loc(2);
1456   sym(1).Node = node;
1457 } break;
1458
1459 case 297: {
1460   AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2));
1461   node->continueToken = loc(1);
1462   node->identifierToken = loc(2);
1463   node->semicolonToken = loc(3);
1464   sym(1).Node = node;
1465 } break;
1466
1467 case 299: {
1468   AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
1469   node->breakToken = loc(1);
1470   node->semicolonToken = loc(2);
1471   sym(1).Node = node;
1472 } break;
1473
1474 case 301: {
1475   AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2));
1476   node->breakToken = loc(1);
1477   node->identifierToken = loc(2);
1478   node->semicolonToken = loc(3);
1479   sym(1).Node = node;
1480 } break;
1481
1482 case 303: {
1483   AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);
1484   node->returnToken = loc(1);
1485   node->semicolonToken = loc(3);
1486   sym(1).Node = node;
1487 } break;
1488
1489 case 304: {
1490   AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement);
1491   node->withToken = loc(1);
1492   node->lparenToken = loc(2);
1493   node->rparenToken = loc(4);
1494   sym(1).Node = node;
1495 } break;
1496
1497 case 305: {
1498   AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock);
1499   node->switchToken = loc(1);
1500   node->lparenToken = loc(2);
1501   node->rparenToken = loc(4);
1502   sym(1).Node = node;
1503 } break;
1504
1505 case 306: {
1506   AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
1507   node->lbraceToken = loc(1);
1508   node->rbraceToken = loc(3);
1509   sym(1).Node = node;
1510 } break;
1511
1512 case 307: {
1513   AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
1514   node->lbraceToken = loc(1);
1515   node->rbraceToken = loc(5);
1516   sym(1).Node = node;
1517 } break;
1518
1519 case 308: {
1520   sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
1521 } break;
1522
1523 case 309: {
1524   sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
1525 } break;
1526
1527 case 310: {
1528   sym(1).Node = 0;
1529 } break;
1530
1531 case 311: {
1532   sym(1).Node = sym(1).CaseClauses->finish ();
1533 } break;
1534
1535 case 312: {
1536   AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList);
1537   node->caseToken = loc(1);
1538   node->colonToken = loc(3);
1539   sym(1).Node = node;
1540 } break;
1541
1542 case 313: {
1543   AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
1544   node->defaultToken = loc(1);
1545   node->colonToken = loc(2);
1546   sym(1).Node = node;
1547 } break;
1548 case 314:
1549 case 315: {
1550   AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
1551   node->identifierToken = loc(1);
1552   node->colonToken = loc(2);
1553   sym(1).Node = node;
1554 } break;
1555
1556 case 316: {
1557   AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
1558   node->identifierToken = loc(1);
1559   node->colonToken = loc(2);
1560   sym(1).Node = node;
1561 } break;
1562
1563 case 318: {
1564   AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
1565   node->throwToken = loc(1);
1566   node->semicolonToken = loc(3);
1567   sym(1).Node = node;
1568 } break;
1569
1570 case 319: {
1571   AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
1572   node->tryToken = loc(1);
1573   sym(1).Node = node;
1574 } break;
1575
1576 case 320: {
1577   AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
1578   node->tryToken = loc(1);
1579   sym(1).Node = node;
1580 } break;
1581
1582 case 321: {
1583   AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally);
1584   node->tryToken = loc(1);
1585   sym(1).Node = node;
1586 } break;
1587
1588 case 322: {
1589   AST::Catch *node = new (pool) AST::Catch(stringRef(3), sym(5).Block);
1590   node->catchToken = loc(1);
1591   node->lparenToken = loc(2);
1592   node->identifierToken = loc(3);
1593   node->rparenToken = loc(4);
1594   sym(1).Node = node;
1595 } break;
1596
1597 case 323: {
1598   AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
1599   node->finallyToken = loc(1);
1600   sym(1).Node = node;
1601 } break;
1602
1603 case 325: {
1604   AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
1605   node->debuggerToken = loc(1);
1606   node->semicolonToken = loc(2);
1607   sym(1).Node = node;
1608 } break;
1609
1610 case 326: {
1611   AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
1612   node->functionToken = loc(1);
1613   node->identifierToken = loc(2);
1614   node->lparenToken = loc(3);
1615   node->rparenToken = loc(5);
1616   node->lbraceToken = loc(6);
1617   node->rbraceToken = loc(8);
1618   sym(1).Node = node;
1619 } break;
1620
1621 case 327: {
1622   AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
1623   node->functionToken = loc(1);
1624   if (! stringRef(2).isNull())
1625       node->identifierToken = loc(2);
1626   node->lparenToken = loc(3);
1627   node->rparenToken = loc(5);
1628   node->lbraceToken = loc(6);
1629   node->rbraceToken = loc(8);
1630   sym(1).Node = node;
1631 } break;
1632
1633 case 328: {
1634   AST::FormalParameterList *node = new (pool) AST::FormalParameterList(stringRef(1));
1635   node->identifierToken = loc(1);
1636   sym(1).Node = node;
1637 } break;
1638
1639 case 329: {
1640   AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, stringRef(3));
1641   node->commaToken = loc(2);
1642   node->identifierToken = loc(3);
1643   sym(1).Node = node;
1644 } break;
1645
1646 case 330: {
1647   sym(1).Node = 0;
1648 } break;
1649
1650 case 331: {
1651   sym(1).Node = sym(1).FormalParameterList->finish ();
1652 } break;
1653
1654 case 332: {
1655   sym(1).Node = 0;
1656 } break;
1657
1658 case 334: {
1659   sym(1).Node = new (pool) AST::FunctionBody(sym(1).SourceElements->finish ());
1660 } break;
1661
1662 case 335: {
1663   sym(1).Node = new (pool) AST::Program(sym(1).SourceElements->finish ());
1664 } break;
1665
1666 case 336: {
1667   sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElement);
1668 } break;
1669
1670 case 337: {
1671   sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElements, sym(2).SourceElement);
1672 } break;
1673
1674 case 338: {
1675   sym(1).Node = new (pool) AST::StatementSourceElement(sym(1).Statement);
1676 } break;
1677
1678 case 339: {
1679   sym(1).Node = new (pool) AST::FunctionSourceElement(sym(1).FunctionDeclaration);
1680 } break;
1681
1682 case 340: {
1683   stringRef(1) = QStringRef();
1684 } break;
1685
1686 case 342: {
1687   sym(1).Node = 0;
1688 } break;
1689
1690             } // switch
1691             action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
1692         } // if
1693     } while (action != 0);
1694
1695     if (first_token == last_token) {
1696         const int errorState = state_stack[tos];
1697
1698         // automatic insertion of `;'
1699         if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && automatic(driver, yytoken)) {
1700             SavedToken &tk = token_buffer[0];
1701             tk.token = yytoken;
1702             tk.dval = yylval;
1703             tk.spell = yytokenspell;
1704             tk.loc = yylloc;
1705
1706             yylloc = yyprevlloc;
1707             yylloc.offset += yylloc.length;
1708             yylloc.startColumn += yylloc.length;
1709             yylloc.length = 0;
1710
1711             //const QString msg = qApp->translate("QDeclarativeParser", "Missing `;'");
1712             //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
1713
1714             first_token = &token_buffer[0];
1715             last_token = &token_buffer[1];
1716
1717             yytoken = T_SEMICOLON;
1718             yylval = 0;
1719
1720             action = errorState;
1721
1722             goto _Lcheck_token;
1723         }
1724
1725         hadErrors = true;
1726
1727         token_buffer[0].token = yytoken;
1728         token_buffer[0].dval = yylval;
1729         token_buffer[0].spell = yytokenspell;
1730         token_buffer[0].loc = yylloc;
1731
1732         token_buffer[1].token = yytoken       = lexer->lex();
1733         token_buffer[1].dval  = yylval        = lexer->tokenValue();
1734         token_buffer[1].spell = yytokenspell  = lexer->tokenSpell();
1735         token_buffer[1].loc   = yylloc        = location(lexer);
1736
1737         if (t_action(errorState, yytoken)) {
1738             QString msg;
1739             int token = token_buffer[0].token;
1740             if (token < 0 || token >= TERMINAL_COUNT)
1741                 msg = qApp->translate("QDeclarativeParser", "Syntax error");
1742             else
1743                 msg = qApp->translate("QDeclarativeParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
1744             diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1745
1746             action = errorState;
1747             goto _Lcheck_token;
1748         }
1749
1750         static int tokens[] = {
1751             T_PLUS,
1752             T_EQ,
1753
1754             T_COMMA,
1755             T_COLON,
1756             T_SEMICOLON,
1757
1758             T_RPAREN, T_RBRACKET, T_RBRACE,
1759
1760             T_NUMERIC_LITERAL,
1761             T_IDENTIFIER,
1762
1763             T_LPAREN, T_LBRACKET, T_LBRACE,
1764
1765             EOF_SYMBOL
1766         };
1767
1768         for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
1769             int a = t_action(errorState, *tk);
1770             if (a > 0 && t_action(a, yytoken)) {
1771                 const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
1772                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1773
1774                 yytoken = *tk;
1775                 yylval = 0;
1776                 yylloc = token_buffer[0].loc;
1777                 yylloc.length = 0;
1778
1779                 first_token = &token_buffer[0];
1780                 last_token = &token_buffer[2];
1781
1782                 action = errorState;
1783                 goto _Lcheck_token;
1784             }
1785         }
1786
1787         for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
1788             if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
1789                 tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION ||
1790                 tk == T_FEED_JS_SOURCE_ELEMENT)
1791                continue;
1792
1793             int a = t_action(errorState, tk);
1794             if (a > 0 && t_action(a, yytoken)) {
1795                 const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
1796                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1797
1798                 yytoken = tk;
1799                 yylval = 0;
1800                 yylloc = token_buffer[0].loc;
1801                 yylloc.length = 0;
1802
1803                 action = errorState;
1804                 goto _Lcheck_token;
1805             }
1806         }
1807
1808         const QString msg = qApp->translate("QDeclarativeParser", "Syntax error");
1809         diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1810     }
1811
1812     return false;
1813 }
1814
1815 QT_QML_END_NAMESPACE
1816
1817