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