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