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   yylloc = loc(1); // adjust the location of the current token
 581
 582   AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
 583     driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
 584   node->literalToken = loc(1);
 585   sym(1).Node = node;
 586 } break;
 587
 588 case 80: {
 589   bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
 590   if (!rx) {
 591     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
 592     return false;
 593   }
 594
 595   loc(1).length = lexer->tokenLength();
 596   yylloc = loc(1); // adjust the location of the current token
 597
 598   AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
 599     driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
 600   node->literalToken = loc(1);
 601   sym(1).Node = node;
 602 } break;
 603
 604 case 81: {
 605   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral((AST::Elision *) 0);
 606   node->lbracketToken = loc(1);
 607   node->rbracketToken = loc(2);
 608   sym(1).Node = node;
 609 } break;
 610
 611 case 82: {
 612   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).Elision->finish());
 613   node->lbracketToken = loc(1);
 614   node->rbracketToken = loc(3);
 615   sym(1).Node = node;
 616 } break;
 617
 618 case 83: {
 619   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish ());
 620   node->lbracketToken = loc(1);
 621   node->rbracketToken = loc(3);
 622   sym(1).Node = node;
 623 } break;
 624
 625 case 84: {
 626   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
 627     (AST::Elision *) 0);
 628   node->lbracketToken = loc(1);
 629   node->commaToken = loc(3);
 630   node->rbracketToken = loc(4);
 631   sym(1).Node = node;
 632 } break;
 633
 634 case 85: {
 635   AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
 636     sym(4).Elision->finish());
 637   node->lbracketToken = loc(1);
 638   node->commaToken = loc(3);
 639   node->rbracketToken = loc(5);
 640   sym(1).Node = node;
 641 } break;
 642
 643 case 86: {
 644   AST::ObjectLiteral *node = 0;
 645   if (sym(2).Node)
 646     node = new (pool) AST::ObjectLiteral(
 647         sym(2).PropertyNameAndValueList->finish ());
 648   else
 649     node = new (pool) AST::ObjectLiteral();
 650   node->lbraceToken = loc(1);
 651   node->rbraceToken = loc(3);
 652   sym(1).Node = node;
 653 } break;
 654
 655 case 87: {
 656   AST::ObjectLiteral *node = new (pool) AST::ObjectLiteral(
 657     sym(2).PropertyNameAndValueList->finish ());
 658   node->lbraceToken = loc(1);
 659   node->rbraceToken = loc(4);
 660   sym(1).Node = node;
 661 } break;
 662
 663 case 88: {
 664   AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression);
 665   node->lparenToken = loc(1);
 666   node->rparenToken = loc(3);
 667   sym(1).Node = node;
 668 } break;
 669
 670 case 89: {
 671   if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
 672     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken,
 673       QLatin1String("Ignored annotation")));
 674
 675     sym(1).Expression = mem->base;
 676   }
 677
 678   if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
 679     sym(1).UiQualifiedId = qualifiedId;
 680   } else {
 681     sym(1).UiQualifiedId = 0;
 682
 683     diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
 684       QLatin1String("Expected a qualified name id")));
 685
 686     return false; // ### recover
 687   }
 688 } break;
 689
 690 case 90: {
 691   sym(1).Node = new (pool) AST::ElementList((AST::Elision *) 0, sym(1).Expression);
 692 } break;
 693
 694 case 91: {
 695   sym(1).Node = new (pool) AST::ElementList(sym(1).Elision->finish(), sym(2).Expression);
 696 } break;
 697
 698 case 92: {
 699   AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList,
 700     (AST::Elision *) 0, sym(3).Expression);
 701   node->commaToken = loc(2);
 702   sym(1).Node = node;
 703 } break;
 704
 705 case 93: {
 706   AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList, sym(3).Elision->finish(),
 707     sym(4).Expression);
 708   node->commaToken = loc(2);
 709   sym(1).Node = node;
 710 } break;
 711
 712 case 94: {
 713   AST::Elision *node = new (pool) AST::Elision();
 714   node->commaToken = loc(1);
 715   sym(1).Node = node;
 716 } break;
 717
 718 case 95: {
 719   AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
 720   node->commaToken = loc(2);
 721   sym(1).Node = node;
 722 } break;
 723
 724 case 96: {
 725   AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
 726       sym(1).PropertyName, sym(3).Expression);
 727   node->colonToken = loc(2);
 728   sym(1).Node = node;
 729 } break;
 730
 731 case 97: {
 732   AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
 733       sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
 734   node->commaToken = loc(2);
 735   node->colonToken = loc(4);
 736   sym(1).Node = node;
 737 } break;
 738
 739 case 98: {
 740   AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
 741   node->propertyNameToken = loc(1);
 742   sym(1).Node = node;
 743 } break;
 744 case 99:
 745 case 100: {
 746   AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
 747   node->propertyNameToken = loc(1);
 748   sym(1).Node = node;
 749 } break;
 750
 751 case 101: {
 752   AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
 753   node->propertyNameToken = loc(1);
 754   sym(1).Node = node;
 755 } break;
 756
 757 case 102: {
 758   AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
 759   node->propertyNameToken = loc(1);
 760   sym(1).Node = node;
 761 } break;
 762
 763 case 103: {
 764   AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
 765   node->propertyNameToken = loc(1);
 766   sym(1).Node = node;
 767 } break;
 768
 769 case 139: {
 770   AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
 771   node->lbracketToken = loc(2);
 772   node->rbracketToken = loc(4);
 773   sym(1).Node = node;
 774 } break;
 775
 776 case 140: {
 777   AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
 778   node->dotToken = loc(2);
 779   node->identifierToken = loc(3);
 780   sym(1).Node = node;
 781 } break;
 782
 783 case 141: {
 784   AST::NewMemberExpression *node = new (pool) AST::NewMemberExpression(sym(2).Expression, sym(4).ArgumentList);
 785   node->newToken = loc(1);
 786   node->lparenToken = loc(3);
 787   node->rparenToken = loc(5);
 788   sym(1).Node = node;
 789 } break;
 790
 791 case 143: {
 792   AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
 793   node->newToken = loc(1);
 794   sym(1).Node = node;
 795 } break;
 796
 797 case 144: {
 798   AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
 799   node->lparenToken = loc(2);
 800   node->rparenToken = loc(4);
 801   sym(1).Node = node;
 802 } break;
 803
 804 case 145: {
 805   AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
 806   node->lparenToken = loc(2);
 807   node->rparenToken = loc(4);
 808   sym(1).Node = node;
 809 } break;
 810
 811 case 146: {
 812   AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
 813   node->lbracketToken = loc(2);
 814   node->rbracketToken = loc(4);
 815   sym(1).Node = node;
 816 } break;
 817
 818 case 147: {
 819   AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
 820   node->dotToken = loc(2);
 821   node->identifierToken = loc(3);
 822   sym(1).Node = node;
 823 } break;
 824
 825 case 148: {
 826   sym(1).Node = 0;
 827 } break;
 828
 829 case 149: {
 830   sym(1).Node = sym(1).ArgumentList->finish();
 831 } break;
 832
 833 case 150: {
 834   sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
 835 } break;
 836
 837 case 151: {
 838   AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
 839   node->commaToken = loc(2);
 840   sym(1).Node = node;
 841 } break;
 842
 843 case 155: {
 844   AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
 845   node->incrementToken = loc(2);
 846   sym(1).Node = node;
 847 } break;
 848
 849 case 156: {
 850   AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
 851   node->decrementToken = loc(2);
 852   sym(1).Node = node;
 853 } break;
 854
 855 case 158: {
 856   AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
 857   node->deleteToken = loc(1);
 858   sym(1).Node = node;
 859 } break;
 860
 861 case 159: {
 862   AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
 863   node->voidToken = loc(1);
 864   sym(1).Node = node;
 865 } break;
 866
 867 case 160: {
 868   AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
 869   node->typeofToken = loc(1);
 870   sym(1).Node = node;
 871 } break;
 872
 873 case 161: {
 874   AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
 875   node->incrementToken = loc(1);
 876   sym(1).Node = node;
 877 } break;
 878
 879 case 162: {
 880   AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
 881   node->decrementToken = loc(1);
 882   sym(1).Node = node;
 883 } break;
 884
 885 case 163: {
 886   AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
 887   node->plusToken = loc(1);
 888   sym(1).Node = node;
 889 } break;
 890
 891 case 164: {
 892   AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
 893   node->minusToken = loc(1);
 894   sym(1).Node = node;
 895 } break;
 896
 897 case 165: {
 898   AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
 899   node->tildeToken = loc(1);
 900   sym(1).Node = node;
 901 } break;
 902
 903 case 166: {
 904   AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
 905   node->notToken = loc(1);
 906   sym(1).Node = node;
 907 } break;
 908
 909 case 168: {
 910   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 911     QSOperator::Mul, sym(3).Expression);
 912   node->operatorToken = loc(2);
 913   sym(1).Node = node;
 914 } break;
 915
 916 case 169: {
 917   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 918     QSOperator::Div, sym(3).Expression);
 919   node->operatorToken = loc(2);
 920   sym(1).Node = node;
 921 } break;
 922
 923 case 170: {
 924   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 925     QSOperator::Mod, sym(3).Expression);
 926   node->operatorToken = loc(2);
 927   sym(1).Node = node;
 928 } break;
 929
 930 case 172: {
 931   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 932     QSOperator::Add, sym(3).Expression);
 933   node->operatorToken = loc(2);
 934   sym(1).Node = node;
 935 } break;
 936
 937 case 173: {
 938   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 939     QSOperator::Sub, sym(3).Expression);
 940   node->operatorToken = loc(2);
 941   sym(1).Node = node;
 942 } break;
 943
 944 case 175: {
 945   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 946     QSOperator::LShift, sym(3).Expression);
 947   node->operatorToken = loc(2);
 948   sym(1).Node = node;
 949 } break;
 950
 951 case 176: {
 952   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 953     QSOperator::RShift, sym(3).Expression);
 954   node->operatorToken = loc(2);
 955   sym(1).Node = node;
 956 } break;
 957
 958 case 177: {
 959   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 960     QSOperator::URShift, sym(3).Expression);
 961   node->operatorToken = loc(2);
 962   sym(1).Node = node;
 963 } break;
 964
 965 case 179: {
 966   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 967     QSOperator::Lt, sym(3).Expression);
 968   node->operatorToken = loc(2);
 969   sym(1).Node = node;
 970 } break;
 971
 972 case 180: {
 973   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 974     QSOperator::Gt, sym(3).Expression);
 975   node->operatorToken = loc(2);
 976   sym(1).Node = node;
 977 } break;
 978
 979 case 181: {
 980   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 981     QSOperator::Le, sym(3).Expression);
 982   node->operatorToken = loc(2);
 983   sym(1).Node = node;
 984 } break;
 985
 986 case 182: {
 987   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 988     QSOperator::Ge, sym(3).Expression);
 989   node->operatorToken = loc(2);
 990   sym(1).Node = node;
 991 } break;
 992
 993 case 183: {
 994   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
 995     QSOperator::InstanceOf, sym(3).Expression);
 996   node->operatorToken = loc(2);
 997   sym(1).Node = node;
 998 } break;
 999
1000 case 184: {
1001   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1002     QSOperator::In, sym(3).Expression);
1003   node->operatorToken = loc(2);
1004   sym(1).Node = node;
1005 } break;
1006
1007 case 186: {
1008   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1009     QSOperator::Lt, sym(3).Expression);
1010   node->operatorToken = loc(2);
1011   sym(1).Node = node;
1012 } break;
1013
1014 case 187: {
1015   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1016     QSOperator::Gt, sym(3).Expression);
1017   node->operatorToken = loc(2);
1018   sym(1).Node = node;
1019 } break;
1020
1021 case 188: {
1022   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1023     QSOperator::Le, sym(3).Expression);
1024   node->operatorToken = loc(2);
1025   sym(1).Node = node;
1026 } break;
1027
1028 case 189: {
1029   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1030    QSOperator::Ge, sym(3).Expression);
1031   node->operatorToken = loc(2);
1032   sym(1).Node = node;
1033 } break;
1034
1035 case 190: {
1036   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1037     QSOperator::InstanceOf, sym(3).Expression);
1038   node->operatorToken = loc(2);
1039   sym(1).Node = node;
1040 } break;
1041
1042 case 192: {
1043   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1044     QSOperator::Equal, sym(3).Expression);
1045   node->operatorToken = loc(2);
1046   sym(1).Node = node;
1047 } break;
1048
1049 case 193: {
1050   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1051     QSOperator::NotEqual, sym(3).Expression);
1052   node->operatorToken = loc(2);
1053   sym(1).Node = node;
1054 } break;
1055
1056 case 194: {
1057   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1058     QSOperator::StrictEqual, sym(3).Expression);
1059   node->operatorToken = loc(2);
1060   sym(1).Node = node;
1061 } break;
1062
1063 case 195: {
1064   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1065     QSOperator::StrictNotEqual, sym(3).Expression);
1066   node->operatorToken = loc(2);
1067   sym(1).Node = node;
1068 } break;
1069
1070 case 197: {
1071   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1072     QSOperator::Equal, sym(3).Expression);
1073   node->operatorToken = loc(2);
1074   sym(1).Node = node;
1075 } break;
1076
1077 case 198: {
1078   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1079     QSOperator::NotEqual, sym(3).Expression);
1080   node->operatorToken = loc(2);
1081   sym(1).Node = node;
1082 } break;
1083
1084 case 199: {
1085   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1086     QSOperator::StrictEqual, sym(3).Expression);
1087   node->operatorToken = loc(2);
1088   sym(1).Node = node;
1089 } break;
1090
1091 case 200: {
1092   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1093     QSOperator::StrictNotEqual, sym(3).Expression);
1094   node->operatorToken = loc(2);
1095   sym(1).Node = node;
1096 } break;
1097
1098 case 202: {
1099   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1100     QSOperator::BitAnd, sym(3).Expression);
1101   node->operatorToken = loc(2);
1102   sym(1).Node = node;
1103 } break;
1104
1105 case 204: {
1106   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1107     QSOperator::BitAnd, sym(3).Expression);
1108   node->operatorToken = loc(2);
1109   sym(1).Node = node;
1110 } break;
1111
1112 case 206: {
1113   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1114     QSOperator::BitXor, sym(3).Expression);
1115   node->operatorToken = loc(2);
1116   sym(1).Node = node;
1117 } break;
1118
1119 case 208: {
1120   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1121     QSOperator::BitXor, sym(3).Expression);
1122   node->operatorToken = loc(2);
1123   sym(1).Node = node;
1124 } break;
1125
1126 case 210: {
1127   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1128     QSOperator::BitOr, sym(3).Expression);
1129   node->operatorToken = loc(2);
1130   sym(1).Node = node;
1131 } break;
1132
1133 case 212: {
1134   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1135     QSOperator::BitOr, sym(3).Expression);
1136   node->operatorToken = loc(2);
1137   sym(1).Node = node;
1138 } break;
1139
1140 case 214: {
1141   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1142     QSOperator::And, sym(3).Expression);
1143   node->operatorToken = loc(2);
1144   sym(1).Node = node;
1145 } break;
1146
1147 case 216: {
1148   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1149     QSOperator::And, sym(3).Expression);
1150   node->operatorToken = loc(2);
1151   sym(1).Node = node;
1152 } break;
1153
1154 case 218: {
1155   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1156     QSOperator::Or, sym(3).Expression);
1157   node->operatorToken = loc(2);
1158   sym(1).Node = node;
1159 } break;
1160
1161 case 220: {
1162   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1163     QSOperator::Or, sym(3).Expression);
1164   node->operatorToken = loc(2);
1165   sym(1).Node = node;
1166 } break;
1167
1168 case 222: {
1169   AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
1170     sym(3).Expression, sym(5).Expression);
1171   node->questionToken = loc(2);
1172   node->colonToken = loc(4);
1173   sym(1).Node = node;
1174 } break;
1175
1176 case 224: {
1177   AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
1178     sym(3).Expression, sym(5).Expression);
1179   node->questionToken = loc(2);
1180   node->colonToken = loc(4);
1181   sym(1).Node = node;
1182 } break;
1183
1184 case 226: {
1185   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1186     sym(2).ival, sym(3).Expression);
1187   node->operatorToken = loc(2);
1188   sym(1).Node = node;
1189 } break;
1190
1191 case 228: {
1192   AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
1193     sym(2).ival, sym(3).Expression);
1194   node->operatorToken = loc(2);
1195   sym(1).Node = node;
1196 } break;
1197
1198 case 229: {
1199   sym(1).ival = QSOperator::Assign;
1200 } break;
1201
1202 case 230: {
1203   sym(1).ival = QSOperator::InplaceMul;
1204 } break;
1205
1206 case 231: {
1207   sym(1).ival = QSOperator::InplaceDiv;
1208 } break;
1209
1210 case 232: {
1211   sym(1).ival = QSOperator::InplaceMod;
1212 } break;
1213
1214 case 233: {
1215   sym(1).ival = QSOperator::InplaceAdd;
1216 } break;
1217
1218 case 234: {
1219   sym(1).ival = QSOperator::InplaceSub;
1220 } break;
1221
1222 case 235: {
1223   sym(1).ival = QSOperator::InplaceLeftShift;
1224 } break;
1225
1226 case 236: {
1227   sym(1).ival = QSOperator::InplaceRightShift;
1228 } break;
1229
1230 case 237: {
1231   sym(1).ival = QSOperator::InplaceURightShift;
1232 } break;
1233
1234 case 238: {
1235   sym(1).ival = QSOperator::InplaceAnd;
1236 } break;
1237
1238 case 239: {
1239   sym(1).ival = QSOperator::InplaceXor;
1240 } break;
1241
1242 case 240: {
1243   sym(1).ival = QSOperator::InplaceOr;
1244 } break;
1245
1246 case 242: {
1247   AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
1248   node->commaToken = loc(2);
1249   sym(1).Node = node;
1250 } break;
1251
1252 case 243: {
1253   sym(1).Node = 0;
1254 } break;
1255
1256 case 246: {
1257   AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
1258   node->commaToken = loc(2);
1259   sym(1).Node = node;
1260 } break;
1261
1262 case 247: {
1263   sym(1).Node = 0;
1264 } break;
1265
1266 case 264: {
1267   AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
1268   node->lbraceToken = loc(1);
1269   node->rbraceToken = loc(3);
1270   sym(1).Node = node;
1271 } break;
1272
1273 case 265: {
1274   sym(1).Node = new (pool) AST::StatementList(sym(1).Statement);
1275 } break;
1276
1277 case 266: {
1278   sym(1).Node = new (pool) AST::StatementList(sym(1).StatementList, sym(2).Statement);
1279 } break;
1280
1281 case 267: {
1282   sym(1).Node = 0;
1283 } break;
1284
1285 case 268: {
1286   sym(1).Node = sym(1).StatementList->finish ();
1287 } break;
1288
1289 case 270: {
1290   AST::VariableStatement *node = new (pool) AST::VariableStatement(
1291      sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
1292   node->declarationKindToken = loc(1);
1293   node->semicolonToken = loc(3);
1294   sym(1).Node = node;
1295 } break;
1296
1297 case 271: {
1298   sym(1).ival = T_CONST;
1299 } break;
1300
1301 case 272: {
1302   sym(1).ival = T_VAR;
1303 } break;
1304
1305 case 273: {
1306   sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
1307 } break;
1308
1309 case 274: {
1310   AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(
1311     sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
1312   node->commaToken = loc(2);
1313   sym(1).Node = node;
1314 } break;
1315
1316 case 275: {
1317   sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
1318 } break;
1319
1320 case 276: {
1321   sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
1322 } break;
1323
1324 case 277: {
1325   AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
1326   node->identifierToken = loc(1);
1327   sym(1).Node = node;
1328 } break;
1329
1330 case 278: {
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 279: {
1337   // ### TODO: AST for initializer
1338   sym(1) = sym(2);
1339 } break;
1340
1341 case 280: {
1342   sym(1).Node = 0;
1343 } break;
1344
1345 case 282: {
1346   // ### TODO: AST for initializer
1347   sym(1) = sym(2);
1348 } break;
1349
1350 case 283: {
1351   sym(1).Node = 0;
1352 } break;
1353
1354 case 285: {
1355   AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
1356   node->semicolonToken = loc(1);
1357   sym(1).Node = node;
1358 } break;
1359
1360 case 287: {
1361   AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
1362   node->semicolonToken = loc(2);
1363   sym(1).Node = node;
1364 } break;
1365
1366 case 288: {
1367   AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement, sym(7).Statement);
1368   node->ifToken = loc(1);
1369   node->lparenToken = loc(2);
1370   node->rparenToken = loc(4);
1371   node->elseToken = loc(6);
1372   sym(1).Node = node;
1373 } break;
1374
1375 case 289: {
1376   AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement);
1377   node->ifToken = loc(1);
1378   node->lparenToken = loc(2);
1379   node->rparenToken = loc(4);
1380   sym(1).Node = node;
1381 } break;
1382
1383 case 291: {
1384   AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression);
1385   node->doToken = loc(1);
1386   node->whileToken = loc(3);
1387   node->lparenToken = loc(4);
1388   node->rparenToken = loc(6);
1389   node->semicolonToken = loc(7);
1390   sym(1).Node = node;
1391 } break;
1392
1393 case 292: {
1394   AST::WhileStatement *node = new (pool) AST::WhileStatement(sym(3).Expression, sym(5).Statement);
1395   node->whileToken = loc(1);
1396   node->lparenToken = loc(2);
1397   node->rparenToken = loc(4);
1398   sym(1).Node = node;
1399 } break;
1400
1401 case 293: {
1402   AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression,
1403     sym(5).Expression, sym(7).Expression, sym(9).Statement);
1404   node->forToken = loc(1);
1405   node->lparenToken = loc(2);
1406   node->firstSemicolonToken = loc(4);
1407   node->secondSemicolonToken = loc(6);
1408   node->rparenToken = loc(8);
1409   sym(1).Node = node;
1410 } break;
1411
1412 case 294: {
1413   AST::LocalForStatement *node = new (pool) AST::LocalForStatement(
1414      sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
1415      sym(8).Expression, sym(10).Statement);
1416   node->forToken = loc(1);
1417   node->lparenToken = loc(2);
1418   node->varToken = loc(3);
1419   node->firstSemicolonToken = loc(5);
1420   node->secondSemicolonToken = loc(7);
1421   node->rparenToken = loc(9);
1422   sym(1).Node = node;
1423 } break;
1424
1425 case 295: {
1426   AST:: ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression,
1427     sym(5).Expression, sym(7).Statement);
1428   node->forToken = loc(1);
1429   node->lparenToken = loc(2);
1430   node->inToken = loc(4);
1431   node->rparenToken = loc(6);
1432   sym(1).Node = node;
1433 } break;
1434
1435 case 296: {
1436   AST::LocalForEachStatement *node = new (pool) AST::LocalForEachStatement(
1437     sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
1438   node->forToken = loc(1);
1439   node->lparenToken = loc(2);
1440   node->varToken = loc(3);
1441   node->inToken = loc(5);
1442   node->rparenToken = loc(7);
1443   sym(1).Node = node;
1444 } break;
1445
1446 case 298: {
1447   AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
1448   node->continueToken = loc(1);
1449   node->semicolonToken = loc(2);
1450   sym(1).Node = node;
1451 } break;
1452
1453 case 300: {
1454   AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2));
1455   node->continueToken = loc(1);
1456   node->identifierToken = loc(2);
1457   node->semicolonToken = loc(3);
1458   sym(1).Node = node;
1459 } break;
1460
1461 case 302: {
1462   AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
1463   node->breakToken = loc(1);
1464   node->semicolonToken = loc(2);
1465   sym(1).Node = node;
1466 } break;
1467
1468 case 304: {
1469   AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2));
1470   node->breakToken = loc(1);
1471   node->identifierToken = loc(2);
1472   node->semicolonToken = loc(3);
1473   sym(1).Node = node;
1474 } break;
1475
1476 case 306: {
1477   AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);
1478   node->returnToken = loc(1);
1479   node->semicolonToken = loc(3);
1480   sym(1).Node = node;
1481 } break;
1482
1483 case 307: {
1484   AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement);
1485   node->withToken = loc(1);
1486   node->lparenToken = loc(2);
1487   node->rparenToken = loc(4);
1488   sym(1).Node = node;
1489 } break;
1490
1491 case 308: {
1492   AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock);
1493   node->switchToken = loc(1);
1494   node->lparenToken = loc(2);
1495   node->rparenToken = loc(4);
1496   sym(1).Node = node;
1497 } break;
1498
1499 case 309: {
1500   AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
1501   node->lbraceToken = loc(1);
1502   node->rbraceToken = loc(3);
1503   sym(1).Node = node;
1504 } break;
1505
1506 case 310: {
1507   AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
1508   node->lbraceToken = loc(1);
1509   node->rbraceToken = loc(5);
1510   sym(1).Node = node;
1511 } break;
1512
1513 case 311: {
1514   sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
1515 } break;
1516
1517 case 312: {
1518   sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
1519 } break;
1520
1521 case 313: {
1522   sym(1).Node = 0;
1523 } break;
1524
1525 case 314: {
1526   sym(1).Node = sym(1).CaseClauses->finish ();
1527 } break;
1528
1529 case 315: {
1530   AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList);
1531   node->caseToken = loc(1);
1532   node->colonToken = loc(3);
1533   sym(1).Node = node;
1534 } break;
1535
1536 case 316: {
1537   AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
1538   node->defaultToken = loc(1);
1539   node->colonToken = loc(2);
1540   sym(1).Node = node;
1541 } break;
1542 case 317:
1543 case 318: {
1544   AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
1545   node->identifierToken = loc(1);
1546   node->colonToken = loc(2);
1547   sym(1).Node = node;
1548 } break;
1549
1550 case 319: {
1551   AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
1552   node->identifierToken = loc(1);
1553   node->colonToken = loc(2);
1554   sym(1).Node = node;
1555 } break;
1556
1557 case 321: {
1558   AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
1559   node->throwToken = loc(1);
1560   node->semicolonToken = loc(3);
1561   sym(1).Node = node;
1562 } break;
1563
1564 case 322: {
1565   AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
1566   node->tryToken = loc(1);
1567   sym(1).Node = node;
1568 } break;
1569
1570 case 323: {
1571   AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
1572   node->tryToken = loc(1);
1573   sym(1).Node = node;
1574 } break;
1575
1576 case 324: {
1577   AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally);
1578   node->tryToken = loc(1);
1579   sym(1).Node = node;
1580 } break;
1581
1582 case 325: {
1583   AST::Catch *node = new (pool) AST::Catch(stringRef(3), sym(5).Block);
1584   node->catchToken = loc(1);
1585   node->lparenToken = loc(2);
1586   node->identifierToken = loc(3);
1587   node->rparenToken = loc(4);
1588   sym(1).Node = node;
1589 } break;
1590
1591 case 326: {
1592   AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
1593   node->finallyToken = loc(1);
1594   sym(1).Node = node;
1595 } break;
1596
1597 case 328: {
1598   AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
1599   node->debuggerToken = loc(1);
1600   node->semicolonToken = loc(2);
1601   sym(1).Node = node;
1602 } break;
1603
1604 case 329: {
1605   AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
1606   node->functionToken = loc(1);
1607   node->identifierToken = loc(2);
1608   node->lparenToken = loc(3);
1609   node->rparenToken = loc(5);
1610   node->lbraceToken = loc(6);
1611   node->rbraceToken = loc(8);
1612   sym(1).Node = node;
1613 } break;
1614
1615 case 330: {
1616   AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
1617   node->functionToken = loc(1);
1618   if (! stringRef(2).isNull())
1619       node->identifierToken = loc(2);
1620   node->lparenToken = loc(3);
1621   node->rparenToken = loc(5);
1622   node->lbraceToken = loc(6);
1623   node->rbraceToken = loc(8);
1624   sym(1).Node = node;
1625 } break;
1626
1627 case 331: {
1628   AST::FormalParameterList *node = new (pool) AST::FormalParameterList(stringRef(1));
1629   node->identifierToken = loc(1);
1630   sym(1).Node = node;
1631 } break;
1632
1633 case 332: {
1634   AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, stringRef(3));
1635   node->commaToken = loc(2);
1636   node->identifierToken = loc(3);
1637   sym(1).Node = node;
1638 } break;
1639
1640 case 333: {
1641   sym(1).Node = 0;
1642 } break;
1643
1644 case 334: {
1645   sym(1).Node = sym(1).FormalParameterList->finish ();
1646 } break;
1647
1648 case 335: {
1649   sym(1).Node = 0;
1650 } break;
1651
1652 case 337: {
1653   sym(1).Node = new (pool) AST::FunctionBody(sym(1).SourceElements->finish ());
1654 } break;
1655
1656 case 338: {
1657   sym(1).Node = new (pool) AST::Program(sym(1).SourceElements->finish ());
1658 } break;
1659
1660 case 339: {
1661   sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElement);
1662 } break;
1663
1664 case 340: {
1665   sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElements, sym(2).SourceElement);
1666 } break;
1667
1668 case 341: {
1669   sym(1).Node = new (pool) AST::StatementSourceElement(sym(1).Statement);
1670 } break;
1671
1672 case 342: {
1673   sym(1).Node = new (pool) AST::FunctionSourceElement(sym(1).FunctionDeclaration);
1674 } break;
1675
1676 case 343: {
1677   stringRef(1) = QStringRef();
1678 } break;
1679
1680 case 345: {
1681   sym(1).Node = 0;
1682 } break;
1683
1684             } // switch
1685             action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
1686         } // if
1687     } while (action != 0);
1688
1689     if (first_token == last_token) {
1690         const int errorState = state_stack[tos];
1691
1692         // automatic insertion of `;'
1693         if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && lexer->canInsertAutomaticSemicolon(yytoken)) {
1694             SavedToken &tk = token_buffer[0];
1695             tk.token = yytoken;
1696             tk.dval = yylval;
1697             tk.spell = yytokenspell;
1698             tk.loc = yylloc;
1699
1700             yylloc = yyprevlloc;
1701             yylloc.offset += yylloc.length;
1702             yylloc.startColumn += yylloc.length;
1703             yylloc.length = 0;
1704
1705             //const QString msg = qApp->translate("QDeclarativeParser", "Missing `;'");
1706             //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
1707
1708             first_token = &token_buffer[0];
1709             last_token = &token_buffer[1];
1710
1711             yytoken = T_SEMICOLON;
1712             yylval = 0;
1713
1714             action = errorState;
1715
1716             goto _Lcheck_token;
1717         }
1718
1719         hadErrors = true;
1720
1721         token_buffer[0].token = yytoken;
1722         token_buffer[0].dval = yylval;
1723         token_buffer[0].spell = yytokenspell;
1724         token_buffer[0].loc = yylloc;
1725
1726         token_buffer[1].token = yytoken       = lexer->lex();
1727         token_buffer[1].dval  = yylval        = lexer->tokenValue();
1728         token_buffer[1].spell = yytokenspell  = lexer->tokenSpell();
1729         token_buffer[1].loc   = yylloc        = location(lexer);
1730
1731         if (t_action(errorState, yytoken)) {
1732             QString msg;
1733             int token = token_buffer[0].token;
1734             if (token < 0 || token >= TERMINAL_COUNT)
1735                 msg = qApp->translate("QDeclarativeParser", "Syntax error");
1736             else
1737                 msg = qApp->translate("QDeclarativeParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
1738             diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1739
1740             action = errorState;
1741             goto _Lcheck_token;
1742         }
1743
1744         static int tokens[] = {
1745             T_PLUS,
1746             T_EQ,
1747
1748             T_COMMA,
1749             T_COLON,
1750             T_SEMICOLON,
1751
1752             T_RPAREN, T_RBRACKET, T_RBRACE,
1753
1754             T_NUMERIC_LITERAL,
1755             T_IDENTIFIER,
1756
1757             T_LPAREN, T_LBRACKET, T_LBRACE,
1758
1759             EOF_SYMBOL
1760         };
1761
1762         for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
1763             int a = t_action(errorState, *tk);
1764             if (a > 0 && t_action(a, yytoken)) {
1765                 const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
1766                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1767
1768                 yytoken = *tk;
1769                 yylval = 0;
1770                 yylloc = token_buffer[0].loc;
1771                 yylloc.length = 0;
1772
1773                 first_token = &token_buffer[0];
1774                 last_token = &token_buffer[2];
1775
1776                 action = errorState;
1777                 goto _Lcheck_token;
1778             }
1779         }
1780
1781         for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
1782             if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
1783                 tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION ||
1784                 tk == T_FEED_JS_SOURCE_ELEMENT)
1785                continue;
1786
1787             int a = t_action(errorState, tk);
1788             if (a > 0 && t_action(a, yytoken)) {
1789                 const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
1790                 diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1791
1792                 yytoken = tk;
1793                 yylval = 0;
1794                 yylloc = token_buffer[0].loc;
1795                 yylloc.length = 0;
1796
1797                 action = errorState;
1798                 goto _Lcheck_token;
1799             }
1800         }
1801
1802         const QString msg = qApp->translate("QDeclarativeParser", "Syntax error");
1803         diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
1804     }
1805
1806     return false;
1807 }
1808
1809 QT_QML_END_NAMESPACE
1810
1811