src/declarative/qml/parser/qdeclarativejsparser.cpp

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