src/declarative/qml/parser/qdeclarativejsparser.cpp

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