1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 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->lbraceToken = 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->lbraceToken = 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);