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