← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to tools/porting/src/parser.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/porting/src/parser.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
 
4
** Copyright (C) 2001-2004 Roberto Raggi
 
5
**
 
6
** This file is part of the porting application of the Qt Toolkit.
 
7
**
 
8
** This file may be distributed under the terms of the Q Public License
 
9
** as defined by Trolltech AS of Norway and appearing in the file
 
10
** LICENSE.QPL included in the packaging of this file.
 
11
**
 
12
** This file may be distributed and/or modified under the terms of the
 
13
** GNU General Public License version 2 as published by the Free Software
 
14
** Foundation and appearing in the file LICENSE.GPL included in the
 
15
** packaging of this file.
 
16
**
 
17
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
18
**   information about Qt Commercial License Agreements.
 
19
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
20
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
21
**
 
22
** Contact info@trolltech.com if any conditions of this licensing are
 
23
** not clear to you.
 
24
**
 
25
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
26
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
27
**
 
28
****************************************************************************/
 
29
 
 
30
// c++ support
 
31
#include "parser.h"
 
32
#include "tokens.h"
 
33
#include "errors.h"
 
34
 
 
35
// qt
 
36
#include <qstring.h>
 
37
#include <qstringlist.h>
 
38
#include <qdatetime.h>
 
39
 
 
40
#define TT (tokenStream->currentTokenText().data())
 
41
 
 
42
#define ADVANCE(tk, descr) \
 
43
{ \
 
44
  if (tokenStream->lookAhead() != tk) { \
 
45
    reportError(QString("'%1' expected found '%2'").arg(QString(descr)).arg(QString(tokenStream->currentTokenText()))); \
 
46
      return false; \
 
47
  } \
 
48
  advance(); \
 
49
}
 
50
 
 
51
#define ADVANCE_NR(tk, descr) \
 
52
  do { \
 
53
    if (tokenStream->lookAhead() != tk) { \
 
54
        reportError(i18n("'%1' expected found '%2'").arg(QString(descr)).arg(QString(tokenStream->currentTokenText()))); \
 
55
    } \
 
56
    else \
 
57
        advance(); \
 
58
  } while (0)
 
59
 
 
60
#define CHECK(tk, descr) \
 
61
  do { \
 
62
    if (tokenStream->lookAhead() != tk) { \
 
63
        return false; \
 
64
    } \
 
65
    advance(); \
 
66
  } while (0)
 
67
 
 
68
#define MATCH(tk, descr) \
 
69
  do { \
 
70
    if (tokenStream->lookAhead() != tk) { \
 
71
        reportError(Errors::SyntaxError); \
 
72
        return false; \
 
73
    } \
 
74
  } while (0)
 
75
 
 
76
#define UPDATE_POS(_node, start, end) \
 
77
  do { \
 
78
      (_node)->setPosition(start, end); \
 
79
  } while (0)
 
80
 
 
81
#define AST_FROM_TOKEN(node, tk) \
 
82
    AST *node = CreateNode<AST>(m_pool); \
 
83
    UPDATE_POS(node, (tk), (tk)+1);
 
84
 
 
85
#define DUMP_AST(node) \
 
86
  do { \
 
87
    fprintf(stderr, "\n=================================================\n"); \
 
88
    for (int i=node->startToken(); i<node->endToken(); ++i) \
 
89
       fprintf(stderr, "%s", tokenStream->tokenText(i).constData()); \
 
90
    fprintf(stderr, "\n=================================================\n"); \
 
91
  } while (0)
 
92
 
 
93
#define RXX_NO_ERROR
 
94
 
 
95
QString i18n(QString arg)
 
96
{
 
97
    return arg;
 
98
}
 
99
 
 
100
 
 
101
//@todo remove me
 
102
enum
 
103
{
 
104
    OBJC_CLASS,
 
105
    OBJC_PROTOCOL,
 
106
    OBJC_ALIAS
 
107
};
 
108
 
 
109
Parser::Parser()
 
110
{
 
111
    m_maxProblems = 5;
 
112
    objcp = false;
 
113
}
 
114
 
 
115
Parser::~Parser()
 
116
{
 
117
}
 
118
 
 
119
TranslationUnitAST *Parser::parse(TokenStreamAdapter::TokenStream *p_tokenStream, pool *p)
 
120
{
 
121
   //tokenStream->rewind(0);
 
122
    m_pool = p;
 
123
    tokenStream = p_tokenStream;
 
124
    TranslationUnitAST *ast = 0;
 
125
    parseTranslationUnit(ast);
 
126
    return ast;
 
127
}
 
128
 
 
129
/*
 
130
    Parses a part of the translation unit given by tokenStream. When the number
 
131
    of nodes in the AST exeeds targetMaxASTnodes, this function will return as
 
132
    soon as possible. The progress is stored by updating the cursor inside
 
133
    tokenStream. done is set to true if the parser finished parsing the
 
134
    tokenStream, and to false otherwise.
 
135
*/
 
136
TranslationUnitAST *Parser::parse(TokenStreamAdapter::TokenStream *p_tokenStream, pool *p, int targetMaxASTNodes, bool &done)
 
137
{
 
138
    m_pool = p;
 
139
    tokenStream = p_tokenStream;
 
140
    TranslationUnitAST *ast = 0;
 
141
    // we always create one node, so target max nodes cannot be < 2.
 
142
    if (targetMaxASTNodes < 2)
 
143
        targetMaxASTNodes = 2;
 
144
 
 
145
    // Advance past whitespace and comment tokens at the start.
 
146
    while (tokenStream->isHidden(tokenStream->cursor())) {
 
147
        tokenStream->nextToken();
 
148
    }
 
149
    int start = tokenStream->cursor();
 
150
 
 
151
    AST::N = 0;
 
152
    m_problems = 0;
 
153
    ast = CreateNode<TranslationUnitAST>(m_pool);
 
154
    while (tokenStream->lookAhead() && AST::N < targetMaxASTNodes) {
 
155
        DeclarationAST *def = 0;
 
156
        int startDecl = tokenStream->cursor();
 
157
        if (!parseDeclaration(def)) {
 
158
            // error recovery
 
159
            if (startDecl == tokenStream->cursor())
 
160
                advance(); // skip at least one token
 
161
            skipUntilDeclaration();
 
162
        }
 
163
        ast->addDeclaration(def);
 
164
    }
 
165
 
 
166
    UPDATE_POS(ast, start, tokenStream->cursor());
 
167
 
 
168
    done = tokenStream->tokenAtEnd();
 
169
    return ast;
 
170
}
 
171
 
 
172
 
 
173
bool Parser::reportError(const Error& err)
 
174
{
 
175
Q_UNUSED(err);
 
176
#ifndef RXX_NO_ERROR
 
177
    if (m_problems < m_maxProblems) {
 
178
        ++m_problems;
 
179
        int line=0, col=0;
 
180
        QByteArray fileName;
 
181
        tokenStream->getTokenStartPosition(tokenStream->cursor(), &line, &col, &fileName);
 
182
 
 
183
        QString s = tokenStream->currentTokenText();
 
184
        s = s.left(30).trimmed();
 
185
        if (s.isEmpty())
 
186
            s = i18n("<eof>");
 
187
 
 
188
        if (fileName.isEmpty())
 
189
            //fileName = m_file->fileName;
 
190
            fileName = "implement me";
 
191
 
 
192
        //        m_driver->addProblem(m_driver->currentFileName(), Problem(err.text.arg(s), line, col));
 
193
        fprintf(stderr, "%s: error %s at line %d column %d\n",
 
194
                fileName.constData(),
 
195
                err.text.arg(s).toLatin1().constData(), line, col);
 
196
    }
 
197
#endif // RXX_NO_ERROR
 
198
    return true;
 
199
}
 
200
 
 
201
bool Parser::reportError(const QString& msg)
 
202
{
 
203
Q_UNUSED(msg);
 
204
#ifndef RXX_NO_ERROR
 
205
    if (m_problems < m_maxProblems) {
 
206
        ++m_problems;
 
207
        int line=0, col=0;
 
208
        QByteArray fileName;
 
209
        tokenStream->getTokenStartPosition(tokenStream->cursor(), &line, &col, &fileName);
 
210
 
 
211
        if (fileName.isEmpty())
 
212
            //fileName = m_file->fileName;
 
213
            fileName = "implement me";
 
214
 
 
215
        //        m_driver->addProblem(m_driver->currentFileName(), Problem(msg, line, col));
 
216
        fprintf(stderr, "%s: error %s at line %d column %d\n",
 
217
                fileName.constData(),
 
218
                msg.toLatin1().constData(), line, col);
 
219
    }
 
220
#endif // RXX_NO_ERROR
 
221
    return true;
 
222
}
 
223
 
 
224
void Parser::syntaxError()
 
225
{
 
226
    (void) reportError(Errors::SyntaxError);
 
227
}
 
228
 
 
229
bool Parser::skipUntil(int token)
 
230
{
 
231
    while (tokenStream->lookAhead()) {
 
232
        if (tokenStream->lookAhead() == token)
 
233
            return true;
 
234
 
 
235
        advance();
 
236
    }
 
237
 
 
238
    return false;
 
239
}
 
240
 
 
241
bool Parser::skipUntilDeclaration()
 
242
{
 
243
    while (tokenStream->lookAhead()) {
 
244
 
 
245
        switch(tokenStream->lookAhead()) {
 
246
        case ';':
 
247
        case '~':
 
248
        case Token_scope:
 
249
        case Token_identifier:
 
250
        case Token_operator:
 
251
        case Token_char:
 
252
        case Token_wchar_t:
 
253
        case Token_bool:
 
254
        case Token_short:
 
255
        case Token_int:
 
256
        case Token_long:
 
257
        case Token_signed:
 
258
        case Token_unsigned:
 
259
        case Token_float:
 
260
        case Token_double:
 
261
        case Token_void:
 
262
        case Token_extern:
 
263
        case Token_namespace:
 
264
        case Token_using:
 
265
        case Token_typedef:
 
266
        case Token_asm:
 
267
        case Token_template:
 
268
        case Token_export:
 
269
 
 
270
        case Token_const:       // cv
 
271
        case Token_volatile:    // cv
 
272
 
 
273
        case Token_public:
 
274
        case Token_protected:
 
275
        case Token_private:
 
276
        case Token_signals:      // Qt
 
277
        case Token_slots:        // Qt
 
278
              return true;
 
279
 
 
280
        default:
 
281
            advance();
 
282
        }
 
283
    }
 
284
 
 
285
    return false;
 
286
}
 
287
 
 
288
bool Parser::skipUntilStatement()
 
289
{
 
290
    while (tokenStream->lookAhead()) {
 
291
        switch(tokenStream->lookAhead()) {
 
292
                case ';':
 
293
                case '{':
 
294
                case '}':
 
295
                case Token_const:
 
296
                case Token_volatile:
 
297
                case Token_identifier:
 
298
                case Token_case:
 
299
                case Token_default:
 
300
                case Token_if:
 
301
                case Token_switch:
 
302
                case Token_while:
 
303
                case Token_do:
 
304
                case Token_for:
 
305
                case Token_break:
 
306
                case Token_continue:
 
307
                case Token_return:
 
308
                case Token_goto:
 
309
                case Token_try:
 
310
                case Token_catch:
 
311
                case Token_throw:
 
312
                case Token_char:
 
313
                case Token_wchar_t:
 
314
                case Token_bool:
 
315
                case Token_short:
 
316
                case Token_int:
 
317
                case Token_long:
 
318
                case Token_signed:
 
319
                case Token_unsigned:
 
320
                case Token_float:
 
321
                case Token_double:
 
322
                case Token_void:
 
323
                case Token_class:
 
324
                case Token_struct:
 
325
                case Token_union:
 
326
                case Token_enum:
 
327
                case Token_scope:
 
328
                case Token_template:
 
329
                case Token_using:
 
330
                    return true;
 
331
 
 
332
            default:
 
333
                  advance();
 
334
        }
 
335
    }
 
336
 
 
337
    return false;
 
338
}
 
339
 
 
340
bool Parser::skip(int l, int r)
 
341
{
 
342
    int count = 0;
 
343
    while (tokenStream->lookAhead()) {
 
344
        int tk = tokenStream->lookAhead();
 
345
 
 
346
        if (tk == l)
 
347
            ++count;
 
348
        else if (tk == r)
 
349
            --count;
 
350
        else if (l != '{' && (tk == '{' || tk == '}' || tk == ';'))
 
351
            return false;
 
352
 
 
353
        if (count == 0)
 
354
            return true;
 
355
 
 
356
        advance();
 
357
    }
 
358
 
 
359
    return false;
 
360
}
 
361
 
 
362
bool Parser::skipCommaExpression(AbstractExpressionAST *&node)
 
363
{
 
364
#ifndef RXX_NO_PARSE_EXPRESSION
 
365
    return parseCommaExpression(node);
 
366
#else
 
367
    int start = tokenStream->cursor();
 
368
 
 
369
    AbstractExpressionAST *expr = 0;
 
370
    if (!skipExpression(expr))
 
371
        return false;
 
372
 
 
373
    while (tokenStream->lookAhead() == ',') {
 
374
        advance();
 
375
 
 
376
        if (!skipExpression(expr)) {
 
377
            reportError(i18n("expression expected"));
 
378
            return false;
 
379
        }
 
380
    }
 
381
 
 
382
    AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool);
 
383
    UPDATE_POS(ast, start, tokenStream->cursor());
 
384
    node = ast;
 
385
 
 
386
    return true;
 
387
#endif // RXX_NO_PARSE_EXPRESSION
 
388
}
 
389
 
 
390
bool Parser::skipExpression(AbstractExpressionAST *&node)
 
391
{
 
392
#ifndef RXX_NO_PARSE_EXPRESSION
 
393
    return parseExpression(node);
 
394
#else
 
395
    int start = tokenStream->cursor();
 
396
    int count = 0;
 
397
 
 
398
    while (tokenStream->lookAhead()) {
 
399
        int tk = tokenStream->lookAhead();
 
400
 
 
401
        switch(tk) {
 
402
        case '(':
 
403
        case '[':
 
404
        case '{':
 
405
            ++count;
 
406
            advance();
 
407
            break;
 
408
 
 
409
        case ']':
 
410
        case ')':
 
411
        case '}':
 
412
            if (count == 0) {
 
413
                AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool);
 
414
                UPDATE_POS(ast, start, tokenStream->cursor());
 
415
                node = ast;
 
416
                return true;
 
417
            }
 
418
            --count;
 
419
            advance();
 
420
            break;
 
421
 
 
422
        case Token_struct:
 
423
        case Token_union:
 
424
        case Token_class: {
 
425
            int c = tokenStream->cursor();
 
426
            TypeSpecifierAST *spec = 0;
 
427
            if (!parseClassSpecifier(spec))
 
428
                tokenStream->rewind(c + 1);
 
429
        }
 
430
        break;
 
431
 
 
432
        case ',':
 
433
        case ';':
 
434
        case Token_case:
 
435
        case Token_default:
 
436
        case Token_if:
 
437
        case Token_while:
 
438
        case Token_do:
 
439
        case Token_for:
 
440
        case Token_break:
 
441
        case Token_continue:
 
442
        case Token_return:
 
443
        case Token_goto:
 
444
        {
 
445
            if ((tk == ',' || tk == ';') && count > 0) {
 
446
                advance();
 
447
                break;
 
448
            }
 
449
 
 
450
            AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool);
 
451
            UPDATE_POS(ast, start, tokenStream->cursor());
 
452
            node = ast;
 
453
        }
 
454
        return true;
 
455
 
 
456
        default:
 
457
            advance();
 
458
        }
 
459
    }
 
460
 
 
461
    return false;
 
462
#endif // RXX_NO_PARSE_EXPRESSION
 
463
}
 
464
 
 
465
bool Parser::parseName(NameAST *&node, bool parseTemplateId)
 
466
{
 
467
    AST *winDeclSpec = 0;
 
468
    parseWinDeclSpec(winDeclSpec);
 
469
 
 
470
    int start = tokenStream->cursor();
 
471
 
 
472
    NameAST *ast = CreateNode<NameAST>(m_pool);
 
473
 
 
474
    if (tokenStream->lookAhead() == Token_scope) {
 
475
        ast->setGlobal(true);
 
476
        advance();
 
477
    }
 
478
 
 
479
    int idx = tokenStream->cursor();
 
480
 
 
481
    while (true) {
 
482
        ClassOrNamespaceNameAST *n = 0;
 
483
        if (!parseUnqualifiedName(n))
 
484
            return false;
 
485
 
 
486
        if (tokenStream->lookAhead() == Token_scope) {
 
487
            advance();
 
488
            ast->addClassOrNamespaceName(n);
 
489
            if (tokenStream->lookAhead() == Token_template)
 
490
                advance(); /// skip optional template     #### @todo CHECK
 
491
        } else if (!parseTemplateId && n) {
 
492
            tokenStream->rewind(n->startToken());
 
493
            parseUnqualifiedName(n, parseTemplateId);
 
494
            ast->setUnqualifiedName(n);
 
495
            break;
 
496
        } else {
 
497
            ast->setUnqualifiedName(n);
 
498
            break;
 
499
        }
 
500
    }
 
501
 
 
502
    if (idx == tokenStream->cursor())
 
503
        return false;
 
504
 
 
505
    UPDATE_POS(ast, start, tokenStream->cursor());
 
506
    node = ast;
 
507
 
 
508
    return true;
 
509
}
 
510
 
 
511
bool Parser::parseTranslationUnit(TranslationUnitAST *&node)
 
512
{
 
513
    QTime t;
 
514
    t.start();
 
515
 
 
516
    advance();
 
517
    int start = tokenStream->cursor();
 
518
 
 
519
    m_problems = 0;
 
520
    TranslationUnitAST *tun = CreateNode<TranslationUnitAST>(m_pool);
 
521
    node = tun;
 
522
    while (tokenStream->lookAhead()) {
 
523
        DeclarationAST *def = 0;
 
524
        int startDecl = tokenStream->cursor();
 
525
        if (!parseDeclaration(def)) {
 
526
            // error recovery
 
527
            if (startDecl == tokenStream->cursor())
 
528
                advance(); // skip at least one token
 
529
            skipUntilDeclaration();
 
530
        }
 
531
        node->addDeclaration(def);
 
532
    }
 
533
 
 
534
    UPDATE_POS(node, start, tokenStream->cursor());
 
535
 
 
536
    return m_problems == 0;
 
537
}
 
538
 
 
539
bool Parser::parseDeclaration(DeclarationAST *&node)
 
540
{
 
541
    int start = tokenStream->cursor();
 
542
 
 
543
    switch(tokenStream->lookAhead()) {
 
544
 
 
545
    case ';':
 
546
        advance();
 
547
        return true;
 
548
 
 
549
    case Token_extern:
 
550
        return parseLinkageSpecification(node);
 
551
 
 
552
    case Token_namespace:
 
553
        return parseNamespace(node);
 
554
 
 
555
    case Token_using:
 
556
        return parseUsing(node);
 
557
 
 
558
    case Token_typedef:
 
559
        return parseTypedef(node);
 
560
 
 
561
    case Token_asm:
 
562
        return parseAsmDefinition(node);
 
563
 
 
564
    case Token_template:
 
565
    case Token_export:
 
566
        return parseTemplateDeclaration(node);
 
567
 
 
568
    default:
 
569
        {
 
570
            // tokenStream->rewind(start);
 
571
 
 
572
            if (objcp && parseObjcDef(node))
 
573
                return true;
 
574
 
 
575
            tokenStream->rewind(start);
 
576
 
 
577
            AST *storageSpec = 0;
 
578
            parseStorageClassSpecifier(storageSpec);
 
579
 
 
580
            AST *cv = 0;
 
581
            parseCvQualify(cv);
 
582
 
 
583
            TypeSpecifierAST *spec = 0;
 
584
            if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) {
 
585
                spec->setCvQualify(cv);
 
586
 
 
587
                AST *cv2 = 0;
 
588
                parseCvQualify(cv2);
 
589
                spec->setCv2Qualify(cv2);
 
590
 
 
591
                InitDeclaratorListAST *declarators = 0;
 
592
                parseInitDeclaratorList(declarators);
 
593
                ADVANCE(';', ";");
 
594
 
 
595
                SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool);
 
596
                ast->setStorageSpecifier(storageSpec);
 
597
                ast->setTypeSpec(spec);
 
598
                ast->setInitDeclaratorList(declarators);
 
599
                UPDATE_POS(ast, start, tokenStream->cursor());
 
600
                node = ast;
 
601
 
 
602
                return true;
 
603
            }
 
604
 
 
605
            tokenStream->rewind(start);
 
606
            return parseDeclarationInternal(node);
 
607
        }
 
608
 
 
609
    } // end switch
 
610
}
 
611
 
 
612
bool Parser::parseLinkageSpecification(DeclarationAST *&node)
 
613
{
 
614
    int start = tokenStream->cursor();
 
615
 
 
616
    if (tokenStream->lookAhead() != Token_extern) {
 
617
        return false;
 
618
    }
 
619
    advance();
 
620
 
 
621
    LinkageSpecificationAST *ast = CreateNode<LinkageSpecificationAST>(m_pool);
 
622
 
 
623
    int startExternType = tokenStream->cursor();
 
624
    if (tokenStream->lookAhead() == Token_string_literal) {
 
625
        advance();
 
626
        AST *externType = CreateNode<AST>(m_pool);
 
627
        UPDATE_POS(externType, startExternType, tokenStream->cursor());
 
628
 
 
629
        ast->setExternType(externType);
 
630
    }
 
631
 
 
632
    if (tokenStream->lookAhead() == '{') {
 
633
        LinkageBodyAST *linkageBody = 0;
 
634
        parseLinkageBody(linkageBody);
 
635
        ast->setLinkageBody(linkageBody);
 
636
    } else {
 
637
        DeclarationAST *decl = 0;
 
638
        if (!parseDeclaration(decl)) {
 
639
            reportError(i18n("Declaration syntax error"));
 
640
        }
 
641
        ast->setDeclaration(decl);
 
642
    }
 
643
 
 
644
    UPDATE_POS(ast, start, tokenStream->cursor());
 
645
 
 
646
    node = ast;
 
647
 
 
648
    return true;
 
649
}
 
650
 
 
651
bool Parser::parseLinkageBody(LinkageBodyAST *&node)
 
652
{
 
653
 
 
654
    int start = tokenStream->cursor();
 
655
 
 
656
    if (tokenStream->lookAhead() != '{') {
 
657
        return false;
 
658
    }
 
659
    advance();
 
660
 
 
661
    LinkageBodyAST *lba = CreateNode<LinkageBodyAST>(m_pool);
 
662
    node = lba;
 
663
 
 
664
    while (tokenStream->lookAhead()) {
 
665
        int tk = tokenStream->lookAhead();
 
666
 
 
667
        if (tk == '}')
 
668
            break;
 
669
 
 
670
        DeclarationAST *def = 0;
 
671
        int startDecl = tokenStream->cursor();
 
672
        if (parseDeclaration(def)) {
 
673
            node->addDeclaration(def);
 
674
        } else {
 
675
            // error recovery
 
676
            if (startDecl == tokenStream->cursor())
 
677
                advance(); // skip at least one token
 
678
            skipUntilDeclaration();
 
679
        }
 
680
    }
 
681
 
 
682
    if (tokenStream->lookAhead() != '}') {
 
683
        reportError(i18n("} expected"));
 
684
    } else
 
685
        advance();
 
686
 
 
687
    UPDATE_POS(node, start, tokenStream->cursor());
 
688
    return true;
 
689
}
 
690
 
 
691
bool Parser::parseNamespace(DeclarationAST *&node)
 
692
{
 
693
    int start = tokenStream->cursor();
 
694
 
 
695
    if (tokenStream->lookAhead() != Token_namespace) {
 
696
        return false;
 
697
    }
 
698
    advance();
 
699
 
 
700
    int startNamespaceName = tokenStream->cursor();
 
701
    if (tokenStream->lookAhead() == Token_identifier) {
 
702
        advance();
 
703
    }
 
704
    AST *namespaceName = CreateNode<AST>(m_pool);
 
705
    UPDATE_POS(namespaceName, startNamespaceName, tokenStream->cursor());
 
706
 
 
707
    if (tokenStream->lookAhead() == '=') {
 
708
        // namespace alias
 
709
        advance();
 
710
 
 
711
        NameAST *name = 0;
 
712
        if (parseName(name)) {
 
713
            ADVANCE(';', ";");
 
714
 
 
715
            NamespaceAliasAST *ast = CreateNode<NamespaceAliasAST>(m_pool);
 
716
            ast->setNamespaceName(namespaceName);
 
717
            ast->setAliasName(name);
 
718
            UPDATE_POS(ast, start, tokenStream->cursor());
 
719
            node = ast;
 
720
            return true;
 
721
        } else {
 
722
            reportError(i18n("namespace expected"));
 
723
            return false;
 
724
        }
 
725
    } else if (tokenStream->lookAhead() != '{') {
 
726
        reportError(i18n("{ expected"));
 
727
        return false;
 
728
    }
 
729
 
 
730
    NamespaceAST *ast = CreateNode<NamespaceAST>(m_pool);
 
731
    ast->setNamespaceName(namespaceName);
 
732
 
 
733
    LinkageBodyAST *linkageBody = 0;
 
734
    parseLinkageBody(linkageBody);
 
735
 
 
736
    ast->setLinkageBody(linkageBody);
 
737
    UPDATE_POS(ast, start, tokenStream->cursor());
 
738
    node = ast;
 
739
 
 
740
    return true;
 
741
}
 
742
 
 
743
bool Parser::parseUsing(DeclarationAST *&node)
 
744
{
 
745
    int start = tokenStream->cursor();
 
746
 
 
747
    if (tokenStream->lookAhead() != Token_using) {
 
748
        return false;
 
749
    }
 
750
    advance();
 
751
 
 
752
    if (tokenStream->lookAhead() == Token_namespace) {
 
753
        if (!parseUsingDirective(node)) {
 
754
            return false;
 
755
        }
 
756
        UPDATE_POS(node, start, tokenStream->cursor());
 
757
        return true;
 
758
    }
 
759
 
 
760
    UsingAST *ast = CreateNode<UsingAST>(m_pool);
 
761
 
 
762
    int startTypeName = tokenStream->cursor();
 
763
    if (tokenStream->lookAhead() == Token_typename) {
 
764
        advance();
 
765
        AST *tn = CreateNode<AST>(m_pool);
 
766
        UPDATE_POS(tn, startTypeName, tokenStream->cursor());
 
767
        ast->setTypeName(tn);
 
768
    }
 
769
 
 
770
    NameAST *name = 0;
 
771
    if (!parseName(name))
 
772
        return false;
 
773
 
 
774
    ast->setName(name);
 
775
 
 
776
    ADVANCE(';', ";");
 
777
 
 
778
    UPDATE_POS(ast, start, tokenStream->cursor());
 
779
    node = ast;
 
780
 
 
781
    return true;
 
782
}
 
783
 
 
784
bool Parser::parseUsingDirective(DeclarationAST *&node)
 
785
{
 
786
    int start = tokenStream->cursor();
 
787
 
 
788
    if (tokenStream->lookAhead() != Token_namespace) {
 
789
        return false;
 
790
    }
 
791
    advance();
 
792
 
 
793
    NameAST *name = 0;
 
794
    if (!parseName(name)) {
 
795
        reportError(i18n("Namespace name expected"));
 
796
        return false;
 
797
    }
 
798
 
 
799
    ADVANCE(';', ";");
 
800
 
 
801
    UsingDirectiveAST *ast = CreateNode<UsingDirectiveAST>(m_pool);
 
802
    ast->setName(name);
 
803
    UPDATE_POS(ast, start, tokenStream->cursor());
 
804
    node = ast;
 
805
 
 
806
    return true;
 
807
}
 
808
 
 
809
 
 
810
bool Parser::parseOperatorFunctionId(AST *&node)
 
811
{
 
812
    int start = tokenStream->cursor();
 
813
 
 
814
    if (tokenStream->lookAhead() != Token_operator) {
 
815
        return false;
 
816
    }
 
817
    advance();
 
818
 
 
819
    AST *op = 0;
 
820
    if (parseOperator(op)) {
 
821
        AST *asn = CreateNode<AST>(m_pool);
 
822
        node = asn;
 
823
        UPDATE_POS(node, start, tokenStream->cursor());
 
824
        return true;
 
825
    } else {
 
826
        // parse cast operator
 
827
        AST *cv = 0;
 
828
        parseCvQualify(cv);
 
829
 
 
830
        TypeSpecifierAST *spec = 0;
 
831
        if (!parseSimpleTypeSpecifier(spec)) {
 
832
            syntaxError();
 
833
            return false;
 
834
        }
 
835
        spec->setCvQualify(cv);
 
836
 
 
837
        AST *cv2 = 0;
 
838
        parseCvQualify(cv2);
 
839
        spec->setCv2Qualify(cv2);
 
840
 
 
841
        AST *ptrOp = 0;
 
842
        while (parsePtrOperator(ptrOp))
 
843
              ;
 
844
 
 
845
        AST *asn = CreateNode<AST>(m_pool);
 
846
        node = asn;
 
847
        UPDATE_POS(node, start, tokenStream->cursor());
 
848
        return true;
 
849
    }
 
850
}
 
851
 
 
852
bool Parser::parseTemplateArgumentList(TemplateArgumentListAST *&node, bool reportError)
 
853
{
 
854
    int start = tokenStream->cursor();
 
855
 
 
856
    TemplateArgumentListAST *ast = CreateNode<TemplateArgumentListAST>(m_pool);
 
857
 
 
858
    AST *templArg = 0;
 
859
    if (!parseTemplateArgument(templArg))
 
860
        return false;
 
861
    ast->addArgument(templArg);
 
862
 
 
863
    while (tokenStream->lookAhead() == ',') {
 
864
        advance();
 
865
 
 
866
        if (!parseTemplateArgument(templArg)) {
 
867
            if (reportError) {
 
868
               syntaxError();
 
869
               break;
 
870
            } else
 
871
               return false;
 
872
        }
 
873
        ast->addArgument(templArg);
 
874
    }
 
875
 
 
876
    UPDATE_POS(ast, start, tokenStream->cursor());
 
877
    node = ast;
 
878
 
 
879
    return true;
 
880
}
 
881
 
 
882
bool Parser::parseTypedef(DeclarationAST *&node)
 
883
{
 
884
    int start = tokenStream->cursor();
 
885
 
 
886
    if (tokenStream->lookAhead() != Token_typedef) {
 
887
        return false;
 
888
    }
 
889
    advance();
 
890
 
 
891
    TypeSpecifierAST *spec = 0;
 
892
    if (!parseTypeSpecifierOrClassSpec(spec)) {
 
893
        reportError(i18n("Need a type specifier to declare"));
 
894
        return false;
 
895
    }
 
896
 
 
897
    InitDeclaratorListAST *declarators = 0;
 
898
    if (!parseInitDeclaratorList(declarators)) {
 
899
        //reportError(i18n("Need an identifier to declare"));
 
900
        //return false;
 
901
    }
 
902
 
 
903
    ADVANCE(';', ";");
 
904
 
 
905
    TypedefAST *ast = CreateNode<TypedefAST>(m_pool);
 
906
    ast->setTypeSpec(spec);
 
907
    ast->setInitDeclaratorList(declarators);
 
908
    UPDATE_POS(ast, start, tokenStream->cursor());
 
909
    node = ast;
 
910
 
 
911
    return true;
 
912
}
 
913
 
 
914
bool Parser::parseAsmDefinition(DeclarationAST *&node)
 
915
{
 
916
    int start = tokenStream->cursor();
 
917
 
 
918
    ADVANCE(Token_asm, "asm");
 
919
 
 
920
    AST *cv = 0;
 
921
    parseCvQualify(cv);
 
922
 
 
923
    skip('(', ')');
 
924
    advance();
 
925
    ADVANCE(';', ";");
 
926
 
 
927
    DeclarationAST *ast = CreateNode<DeclarationAST>(m_pool);
 
928
    UPDATE_POS(ast, start, tokenStream->cursor());
 
929
    node = ast;
 
930
 
 
931
    return true;
 
932
}
 
933
 
 
934
bool Parser::parseTemplateDeclaration(DeclarationAST *&node)
 
935
{
 
936
    int start = tokenStream->cursor();
 
937
 
 
938
    AST *exp = 0;
 
939
 
 
940
    int startExport = tokenStream->cursor();
 
941
    if (tokenStream->lookAhead() == Token_export) {
 
942
        advance();
 
943
        AST *n = CreateNode<AST>(m_pool);
 
944
        UPDATE_POS(n, startExport, tokenStream->cursor());
 
945
        exp = n;
 
946
    }
 
947
 
 
948
    if (tokenStream->lookAhead() != Token_template) {
 
949
        return false;
 
950
    }
 
951
    advance();
 
952
 
 
953
    TemplateParameterListAST *params = 0;
 
954
    if (tokenStream->lookAhead() == '<') {
 
955
        advance();
 
956
        parseTemplateParameterList(params);
 
957
 
 
958
        ADVANCE('>', ">");
 
959
    }
 
960
 
 
961
    DeclarationAST *def = 0;
 
962
    if (!parseDeclaration(def)) {
 
963
        reportError(i18n("expected a declaration"));
 
964
    }
 
965
 
 
966
    TemplateDeclarationAST *ast = CreateNode<TemplateDeclarationAST>(m_pool);
 
967
    ast->setExported(exp);
 
968
    ast->setTemplateParameterList(params);
 
969
    ast->setDeclaration(def);
 
970
    UPDATE_POS(ast, start, tokenStream->cursor());
 
971
    node = ast;
 
972
 
 
973
    return true;
 
974
}
 
975
 
 
976
bool Parser::parseOperator(AST *&/*node*/)
 
977
{
 
978
    QString text = tokenStream->currentTokenText();
 
979
 
 
980
    switch(tokenStream->lookAhead()) {
 
981
    case Token_new:
 
982
    case Token_delete:
 
983
        advance();
 
984
        if (tokenStream->lookAhead() == '[' && tokenStream->lookAhead(1) == ']') {
 
985
            advance();
 
986
            advance();
 
987
            text += "[]";
 
988
        }
 
989
        return true;
 
990
 
 
991
    case '+':
 
992
    case '-':
 
993
    case '*':
 
994
    case '/':
 
995
    case '%':
 
996
    case '^':
 
997
    case '&':
 
998
    case '|':
 
999
    case '~':
 
1000
    case '!':
 
1001
    case '=':
 
1002
    case '<':
 
1003
    case '>':
 
1004
    case ',':
 
1005
    case Token_assign:
 
1006
    case Token_shift:
 
1007
    case Token_eq:
 
1008
    case Token_not_eq:
 
1009
    case Token_leq:
 
1010
    case Token_geq:
 
1011
    case Token_and:
 
1012
    case Token_or:
 
1013
    case Token_incr:
 
1014
    case Token_decr:
 
1015
    case Token_ptrmem:
 
1016
    case Token_arrow:
 
1017
        advance();
 
1018
        return true;
 
1019
 
 
1020
    default:
 
1021
        if (tokenStream->lookAhead() == '(' && tokenStream->lookAhead(1) == ')') {
 
1022
            advance();
 
1023
            advance();
 
1024
            return true;
 
1025
        } else if (tokenStream->lookAhead() == '[' && tokenStream->lookAhead(1) == ']') {
 
1026
            advance();
 
1027
            advance();
 
1028
            return true;
 
1029
        }
 
1030
    }
 
1031
 
 
1032
    return false;
 
1033
}
 
1034
 
 
1035
bool Parser::parseCvQualify(AST *&node)
 
1036
{
 
1037
    int start = tokenStream->cursor();
 
1038
 
 
1039
    AST *ast = CreateNode<AST>(m_pool);
 
1040
 
 
1041
    int n = 0;
 
1042
    while (tokenStream->lookAhead()) {
 
1043
        int tk = tokenStream->lookAhead();
 
1044
        if (tk == Token_const || tk == Token_volatile) {
 
1045
            ++n;
 
1046
            int startWord = tokenStream->cursor();
 
1047
            advance();
 
1048
            AST *word = CreateNode<AST>(m_pool);
 
1049
            UPDATE_POS(word, startWord, tokenStream->cursor());
 
1050
            word->setParent(ast);
 
1051
        } else
 
1052
            break;
 
1053
    }
 
1054
 
 
1055
    if (n == 0)
 
1056
        return false;
 
1057
 
 
1058
 
 
1059
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1060
 
 
1061
    node = ast;
 
1062
    return true;
 
1063
}
 
1064
 
 
1065
bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST *&node, bool onlyIntegral)
 
1066
{
 
1067
    int start = tokenStream->cursor();
 
1068
    bool isIntegral = false;
 
1069
    bool done = false;
 
1070
 
 
1071
    while (!done) {
 
1072
        switch(tokenStream->lookAhead()) {
 
1073
            case Token_char:
 
1074
            case Token_wchar_t:
 
1075
            case Token_bool:
 
1076
            case Token_short:
 
1077
            case Token_int:
 
1078
            case Token_long:
 
1079
            case Token_signed:
 
1080
            case Token_unsigned:
 
1081
            case Token_float:
 
1082
            case Token_double:
 
1083
            case Token_void:
 
1084
                isIntegral = true;
 
1085
                advance();
 
1086
                break;
 
1087
 
 
1088
            default:
 
1089
                done = true;
 
1090
        }
 
1091
    }
 
1092
 
 
1093
    TypeSpecifierAST *ast = CreateNode<TypeSpecifierAST>(m_pool);
 
1094
    if (isIntegral) {
 
1095
        ClassOrNamespaceNameAST *cl = CreateNode<ClassOrNamespaceNameAST>(m_pool);
 
1096
 
 
1097
        AST *n = CreateNode<AST>(m_pool);
 
1098
        UPDATE_POS(n, start, tokenStream->cursor());
 
1099
        cl->setName(n);
 
1100
        UPDATE_POS(cl, start, tokenStream->cursor());
 
1101
 
 
1102
        NameAST *name = CreateNode<NameAST>(m_pool);
 
1103
        name->setUnqualifiedName(cl);
 
1104
        UPDATE_POS(name, start, tokenStream->cursor());
 
1105
        ast->setName(name);
 
1106
    } else if (tokenStream->lookAhead() == Token___typeof) {
 
1107
        advance();
 
1108
        if (tokenStream->lookAhead() == '(') {
 
1109
            advance();
 
1110
            TypeIdAST *typeId = 0;
 
1111
            parseTypeId(typeId);
 
1112
            ADVANCE(')', ")");
 
1113
        } else {
 
1114
            AbstractExpressionAST *e = 0;
 
1115
            parseUnaryExpression(e);
 
1116
        }
 
1117
    } else if (onlyIntegral) {
 
1118
        tokenStream->rewind(start);
 
1119
        return false;
 
1120
    } else {
 
1121
        NameAST *name = 0;
 
1122
        if (!parseName(name)) {
 
1123
            tokenStream->rewind(start);
 
1124
            return false;
 
1125
        }
 
1126
        ast->setName(name);
 
1127
    }
 
1128
 
 
1129
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1130
    node = ast;
 
1131
    return true;
 
1132
}
 
1133
 
 
1134
bool Parser::parsePtrOperator(AST *&node)
 
1135
{
 
1136
    int start = tokenStream->cursor();
 
1137
    int tok = tokenStream->lookAhead();
 
1138
    AST *memPtr = 0;
 
1139
 
 
1140
    switch (tok) {
 
1141
        case '&':
 
1142
        case '*':
 
1143
            advance();
 
1144
            break;
 
1145
 
 
1146
        case Token_scope:
 
1147
        case Token_identifier:
 
1148
            if (!parsePtrToMember(memPtr)) {
 
1149
                tokenStream->rewind(start);
 
1150
                return false;
 
1151
            }
 
1152
            break;
 
1153
 
 
1154
        default:
 
1155
            return false;
 
1156
    }
 
1157
 
 
1158
    AST *cv = 0;
 
1159
    parseCvQualify(cv);
 
1160
 
 
1161
    AST *ast = CreateNode<AST>(m_pool);
 
1162
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1163
    node = ast;
 
1164
 
 
1165
    return true;
 
1166
}
 
1167
 
 
1168
 
 
1169
bool Parser::parseTemplateArgument(AST *&node)
 
1170
{
 
1171
    int start = tokenStream->cursor();
 
1172
 
 
1173
    TypeIdAST *typeId = 0;
 
1174
    if (parseTypeId(typeId)) {
 
1175
        if (tokenStream->lookAhead() == ',' || tokenStream->lookAhead() == '>') {
 
1176
            node = typeId;
 
1177
            return true;
 
1178
        }
 
1179
    }
 
1180
 
 
1181
    tokenStream->rewind(start);
 
1182
    AbstractExpressionAST *expr = 0;
 
1183
    if (!parseLogicalOrExpression(expr, true)) {
 
1184
        return false;
 
1185
    }
 
1186
    node = expr;
 
1187
 
 
1188
    return true;
 
1189
}
 
1190
 
 
1191
bool Parser::parseTypeSpecifier(TypeSpecifierAST *&spec)
 
1192
{
 
1193
    AST *cv = 0;
 
1194
    parseCvQualify(cv);
 
1195
 
 
1196
    if (parseElaboratedTypeSpecifier(spec) || parseSimpleTypeSpecifier(spec)) {
 
1197
        spec->setCvQualify(cv);
 
1198
 
 
1199
        AST *cv2 = 0;
 
1200
        parseCvQualify(cv2);
 
1201
        spec->setCv2Qualify(cv2);
 
1202
 
 
1203
        return true;
 
1204
    }
 
1205
 
 
1206
    return false;
 
1207
}
 
1208
 
 
1209
bool Parser::parseDeclarator(DeclaratorAST *&node)
 
1210
{
 
1211
    int start = tokenStream->cursor();
 
1212
 
 
1213
    DeclaratorAST *ast = CreateNode<DeclaratorAST>(m_pool);
 
1214
 
 
1215
    DeclaratorAST *decl = 0;
 
1216
    NameAST *declId = 0;
 
1217
 
 
1218
    AST *ptrOp = 0;
 
1219
    while (parsePtrOperator(ptrOp)) {
 
1220
        ast->addPtrOp(ptrOp);
 
1221
    }
 
1222
 
 
1223
    if (tokenStream->lookAhead() == '(') {
 
1224
        advance();
 
1225
 
 
1226
        if (!parseDeclarator(decl)) {
 
1227
            return false;
 
1228
        }
 
1229
        ast->setSubDeclarator(decl);
 
1230
 
 
1231
        if (tokenStream->lookAhead() != ')') {
 
1232
            return false;
 
1233
        }
 
1234
        advance();
 
1235
    } else {
 
1236
        if (tokenStream->lookAhead() == ':') {
 
1237
             // unnamed bitfield
 
1238
        } else if (parseDeclaratorId(declId)) {
 
1239
            ast->setDeclaratorId(declId);
 
1240
        } else {
 
1241
            tokenStream->rewind(start);
 
1242
            return false;
 
1243
        }
 
1244
 
 
1245
        if (tokenStream->lookAhead() == ':') {
 
1246
            advance();
 
1247
            AbstractExpressionAST *expr = 0;
 
1248
            if (!parseConstantExpression(expr)) {
 
1249
                reportError(i18n("Constant expression expected"));
 
1250
            }
 
1251
            goto update_pos;
 
1252
        }
 
1253
    }
 
1254
 
 
1255
    {
 
1256
        bool isVector = true;
 
1257
 
 
1258
        while (tokenStream->lookAhead() == '[') {
 
1259
            int startArray = tokenStream->cursor();
 
1260
            advance();
 
1261
            AbstractExpressionAST *expr = 0;
 
1262
            parseCommaExpression(expr);
 
1263
 
 
1264
            ADVANCE(']', "]");
 
1265
            AST *array = CreateNode<AST>(m_pool);
 
1266
            UPDATE_POS(array, startArray, tokenStream->cursor());
 
1267
            ast->addArrayDimension(array);
 
1268
            isVector = true;
 
1269
        }
 
1270
 
 
1271
        bool skipParen = false;
 
1272
        if (tokenStream->lookAhead() == Token_identifier
 
1273
                && tokenStream->lookAhead(1) == '('
 
1274
                && tokenStream->lookAhead(2) == '(') {
 
1275
            advance();
 
1276
            advance();
 
1277
            skipParen = true;
 
1278
        }
 
1279
 
 
1280
        int tok = tokenStream->lookAhead();
 
1281
        if (ast->subDeclarator() && !(isVector || tok == '(' || tok == ',' || tok == ';' || tok == '=')) {
 
1282
            tokenStream->rewind(start);
 
1283
            return false;
 
1284
        }
 
1285
 
 
1286
        int index = tokenStream->cursor();
 
1287
        if (tokenStream->lookAhead() == '(') {
 
1288
            advance();
 
1289
 
 
1290
            ParameterDeclarationClauseAST *params = 0;
 
1291
            if (!parseParameterDeclarationClause(params)) {
 
1292
                tokenStream->rewind(index);
 
1293
                goto update_pos;
 
1294
            }
 
1295
            ast->setParameterDeclarationClause(params);
 
1296
 
 
1297
            if (tokenStream->lookAhead() != ')') {
 
1298
                tokenStream->rewind(index);
 
1299
                goto update_pos;
 
1300
            }
 
1301
 
 
1302
            advance();  // skip ')'
 
1303
 
 
1304
            AST *constant = 0;
 
1305
            parseCvQualify(constant);
 
1306
            ast->setConstant(constant);
 
1307
 
 
1308
            AST *except = 0;
 
1309
            if (parseExceptionSpecification(except)) {
 
1310
                ast->setExceptionSpecification(except);
 
1311
            }
 
1312
        }
 
1313
 
 
1314
        if (skipParen) {
 
1315
            if (tokenStream->lookAhead() != ')') {
 
1316
                reportError(i18n("')' expected"));
 
1317
            } else
 
1318
                advance();
 
1319
        }
 
1320
    }
 
1321
 
 
1322
update_pos:
 
1323
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1324
    node = ast;
 
1325
 
 
1326
    return true;
 
1327
}
 
1328
 
 
1329
bool Parser::parseAbstractDeclarator(DeclaratorAST *&node)
 
1330
{
 
1331
    int start = tokenStream->cursor();
 
1332
 
 
1333
    DeclaratorAST *ast = CreateNode<DeclaratorAST>(m_pool);
 
1334
    DeclaratorAST *decl = 0;
 
1335
 
 
1336
    AST *ptrOp = 0;
 
1337
    while (parsePtrOperator(ptrOp)) {
 
1338
        ast->addPtrOp(ptrOp);
 
1339
    }
 
1340
 
 
1341
    int index = tokenStream->cursor();
 
1342
    if (tokenStream->lookAhead() == '(') {
 
1343
        advance();
 
1344
 
 
1345
        if (!parseAbstractDeclarator(decl)) {
 
1346
            tokenStream->rewind(index);
 
1347
            goto label1;
 
1348
        }
 
1349
 
 
1350
        ast->setSubDeclarator(decl);
 
1351
 
 
1352
        if (tokenStream->lookAhead() != ')'){
 
1353
            tokenStream->rewind(start);
 
1354
            return false;
 
1355
        }
 
1356
        advance();
 
1357
    } else if (tokenStream->lookAhead() == ':') {
 
1358
        advance();
 
1359
        AbstractExpressionAST *expr = 0;
 
1360
        if (!parseConstantExpression(expr)) {
 
1361
            reportError(i18n("Constant expression expected"));
 
1362
        }
 
1363
        goto update_pos;
 
1364
    }
 
1365
 
 
1366
label1:
 
1367
    {
 
1368
        bool isVector = true;
 
1369
 
 
1370
        while (tokenStream->lookAhead() == '[') {
 
1371
            int startArray = tokenStream->cursor();
 
1372
            advance();
 
1373
            AbstractExpressionAST *expr = 0;
 
1374
            parseCommaExpression(expr);
 
1375
 
 
1376
            ADVANCE(']', "]");
 
1377
            AST *array = CreateNode<AST>(m_pool);
 
1378
            UPDATE_POS(array, startArray, tokenStream->cursor());
 
1379
            ast->addArrayDimension(array);
 
1380
            isVector = true;
 
1381
        }
 
1382
 
 
1383
        int tok = tokenStream->lookAhead();
 
1384
        if (ast->subDeclarator() && !(isVector || tok == '(' || tok == ',' || tok == ';' || tok == '=')) {
 
1385
            tokenStream->rewind(start);
 
1386
            return false;
 
1387
        }
 
1388
 
 
1389
        int index = tokenStream->cursor();
 
1390
        if (tokenStream->lookAhead() == '(') {
 
1391
            advance();
 
1392
 
 
1393
            ParameterDeclarationClauseAST *params = 0;
 
1394
            if (!parseParameterDeclarationClause(params)) {
 
1395
                tokenStream->rewind(index);
 
1396
                goto update_pos;
 
1397
            }
 
1398
            ast->setParameterDeclarationClause(params);
 
1399
 
 
1400
            if (tokenStream->lookAhead() != ')') {
 
1401
                tokenStream->rewind(index);
 
1402
                goto update_pos;
 
1403
            }
 
1404
 
 
1405
            advance();  // skip ')'
 
1406
 
 
1407
            AST *constant = 0;
 
1408
            parseCvQualify(constant);
 
1409
            ast->setConstant(constant);
 
1410
 
 
1411
            AST *except = 0;
 
1412
            if (parseExceptionSpecification(except)) {
 
1413
                ast->setExceptionSpecification(except);
 
1414
            }
 
1415
        }
 
1416
    }
 
1417
 
 
1418
update_pos:
 
1419
    if (tokenStream->cursor() == start)
 
1420
        return false;
 
1421
 
 
1422
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1423
    node = ast;
 
1424
 
 
1425
    return true;
 
1426
}
 
1427
 
 
1428
bool Parser::parseEnumSpecifier(TypeSpecifierAST *&node)
 
1429
{
 
1430
    int start = tokenStream->cursor();
 
1431
 
 
1432
    if (tokenStream->lookAhead() != Token_enum) {
 
1433
        return false;
 
1434
    }
 
1435
 
 
1436
    advance();
 
1437
 
 
1438
    NameAST *name = 0;
 
1439
    parseName(name);
 
1440
 
 
1441
    if (tokenStream->lookAhead() != '{') {
 
1442
        tokenStream->rewind(start);
 
1443
        return false;
 
1444
    }
 
1445
    advance();
 
1446
 
 
1447
    EnumSpecifierAST *ast = CreateNode<EnumSpecifierAST>(m_pool);
 
1448
    ast->setName(name);
 
1449
 
 
1450
    EnumeratorAST *enumerator = 0;
 
1451
    if (parseEnumerator(enumerator)) {
 
1452
        ast->addEnumerator(enumerator);
 
1453
 
 
1454
        while (tokenStream->lookAhead() == ',') {
 
1455
            advance();
 
1456
 
 
1457
            if (!parseEnumerator(enumerator)) {
 
1458
                //reportError(i18n("Enumerator expected"));
 
1459
                break;
 
1460
            }
 
1461
 
 
1462
            ast->addEnumerator(enumerator);
 
1463
        }
 
1464
    }
 
1465
 
 
1466
    if (tokenStream->lookAhead() != '}')
 
1467
        reportError(i18n("} missing"));
 
1468
    else
 
1469
        advance();
 
1470
 
 
1471
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1472
    node = ast;
 
1473
 
 
1474
    return true;
 
1475
}
 
1476
 
 
1477
bool Parser::parseTemplateParameterList(TemplateParameterListAST *&node)
 
1478
{
 
1479
    int start = tokenStream->cursor();
 
1480
 
 
1481
    TemplateParameterListAST *ast = CreateNode<TemplateParameterListAST>(m_pool);
 
1482
 
 
1483
    TemplateParameterAST *param = 0;
 
1484
    if (!parseTemplateParameter(param)) {
 
1485
        return false;
 
1486
    }
 
1487
    ast->addTemplateParameter(param);
 
1488
 
 
1489
    while (tokenStream->lookAhead() == ',') {
 
1490
        advance();
 
1491
 
 
1492
        if (!parseTemplateParameter(param)) {
 
1493
            syntaxError();
 
1494
            break;
 
1495
        } else {
 
1496
            ast->addTemplateParameter(param);
 
1497
        }
 
1498
    }
 
1499
 
 
1500
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1501
    node = ast;
 
1502
 
 
1503
    return true;
 
1504
}
 
1505
 
 
1506
bool Parser::parseTemplateParameter(TemplateParameterAST *&node)
 
1507
{
 
1508
    int start = tokenStream->cursor();
 
1509
    TemplateParameterAST *ast = CreateNode<TemplateParameterAST>(m_pool);
 
1510
 
 
1511
    TypeParameterAST *typeParameter = 0;
 
1512
    ParameterDeclarationAST *param = 0;
 
1513
 
 
1514
    int tk = tokenStream->lookAhead();
 
1515
 
 
1516
    if ((tk == Token_class || tk == Token_typename || tk == Token_template) && parseTypeParameter(typeParameter)) {
 
1517
        ast->setTypeParameter(typeParameter);
 
1518
        goto ok;
 
1519
    }
 
1520
 
 
1521
    if (!parseParameterDeclaration(param))
 
1522
        return false;
 
1523
    ast->setTypeValueParameter(param);
 
1524
 
 
1525
ok:
 
1526
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1527
    node = ast;
 
1528
 
 
1529
    return true;
 
1530
}
 
1531
 
 
1532
bool Parser::parseTypeParameter(TypeParameterAST *&node)
 
1533
{
 
1534
    int start = tokenStream->cursor();
 
1535
    TypeParameterAST *ast = CreateNode<TypeParameterAST>(m_pool);
 
1536
 
 
1537
    AST_FROM_TOKEN(kind, tokenStream->cursor());
 
1538
    ast->setKind(kind);
 
1539
 
 
1540
    switch(tokenStream->lookAhead()) {
 
1541
 
 
1542
    case Token_class:
 
1543
    case Token_typename:
 
1544
        {
 
1545
            advance(); // skip class
 
1546
 
 
1547
            // parse optional name
 
1548
            NameAST *name = 0;
 
1549
            if(parseName(name)){
 
1550
                ast->setName(name);
 
1551
 
 
1552
                if (tokenStream->lookAhead() == '='){
 
1553
                    advance();
 
1554
 
 
1555
                    TypeIdAST *typeId = 0;
 
1556
                    if(!parseTypeId(typeId)){
 
1557
                        //syntaxError();
 
1558
                        tokenStream->rewind(start);
 
1559
                        return false;
 
1560
                    }
 
1561
                    ast->setTypeId(typeId);
 
1562
                } else if (!(tokenStream->lookAhead() == ',' || tokenStream->lookAhead() == '>')) {
 
1563
                    tokenStream->rewind(start);
 
1564
                    return false;
 
1565
                }
 
1566
            }
 
1567
        }
 
1568
        break;
 
1569
 
 
1570
    case Token_template:
 
1571
        {
 
1572
            advance(); // skip template
 
1573
            ADVANCE('<', '<');
 
1574
 
 
1575
            TemplateParameterListAST *params = 0;
 
1576
            if (!parseTemplateParameterList(params)) {
 
1577
                return false;
 
1578
            }
 
1579
            ast->setTemplateParameterList(params);
 
1580
 
 
1581
            ADVANCE('>', ">");
 
1582
 
 
1583
            if (tokenStream->lookAhead() == Token_class)
 
1584
                advance();
 
1585
 
 
1586
            // parse optional name
 
1587
            NameAST *name = 0;
 
1588
            if (parseName(name)) {
 
1589
                ast->setName(name);
 
1590
                if (tokenStream->lookAhead() == '=') {
 
1591
                    advance();
 
1592
 
 
1593
                    TypeIdAST *typeId = 0;
 
1594
                    if (!parseTypeId(typeId)) {
 
1595
                        syntaxError();
 
1596
                        return false;
 
1597
                    }
 
1598
                    ast->setTypeId(typeId);
 
1599
                }
 
1600
            }
 
1601
 
 
1602
            if (tokenStream->lookAhead() == '=') {
 
1603
                advance();
 
1604
 
 
1605
                NameAST *templ_name = 0;
 
1606
                parseName(templ_name);
 
1607
            }
 
1608
        }
 
1609
        break;
 
1610
 
 
1611
    default:
 
1612
        return false;
 
1613
 
 
1614
    } // end switch
 
1615
 
 
1616
 
 
1617
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1618
    node = ast;
 
1619
    return true;
 
1620
}
 
1621
 
 
1622
bool Parser::parseStorageClassSpecifier(AST *&node)
 
1623
{
 
1624
    int start = tokenStream->cursor();
 
1625
    AST *ast = CreateNode<AST>(m_pool);
 
1626
 
 
1627
    while (tokenStream->lookAhead()) {
 
1628
        int tk = tokenStream->lookAhead();
 
1629
        if (tk == Token_friend || tk == Token_auto || tk == Token_register || tk == Token_static ||
 
1630
                tk == Token_extern || tk == Token_mutable) {
 
1631
            int startNode = tokenStream->cursor();
 
1632
            advance();
 
1633
 
 
1634
            AST *n = CreateNode<AST>(m_pool);
 
1635
            UPDATE_POS(n, startNode, tokenStream->cursor());
 
1636
            n->setParent(ast);
 
1637
        } else
 
1638
            break;
 
1639
    }
 
1640
 
 
1641
    if (length(ast->children()) == 0)
 
1642
       return false;
 
1643
 
 
1644
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1645
    node = ast;
 
1646
    return true;
 
1647
}
 
1648
 
 
1649
bool Parser::parseFunctionSpecifier(AST *&node)
 
1650
{
 
1651
    int start = tokenStream->cursor();
 
1652
    AST *ast = CreateNode<AST>(m_pool);
 
1653
 
 
1654
    while (tokenStream->lookAhead()) {
 
1655
        int tk = tokenStream->lookAhead();
 
1656
        if (tk == Token_inline || tk == Token_virtual || tk == Token_explicit) {
 
1657
            int startNode = tokenStream->cursor();
 
1658
            advance();
 
1659
 
 
1660
            AST *n = CreateNode<AST>(m_pool);
 
1661
            UPDATE_POS(n, startNode, tokenStream->cursor());
 
1662
            n->setParent(ast);
 
1663
        } else {
 
1664
            break;
 
1665
    }
 
1666
    }
 
1667
 
 
1668
    if (length(ast->children()) == 0)
 
1669
       return false;
 
1670
 
 
1671
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1672
    node = ast;
 
1673
    return true;
 
1674
}
 
1675
 
 
1676
bool Parser::parseTypeId(TypeIdAST *&node)
 
1677
{
 
1678
    /// @todo implement the AST for typeId
 
1679
    int start = tokenStream->cursor();
 
1680
 
 
1681
    TypeSpecifierAST *spec = 0;
 
1682
    if (!parseTypeSpecifier(spec)) {
 
1683
        tokenStream->rewind(start);
 
1684
        return false;
 
1685
    }
 
1686
 
 
1687
    DeclaratorAST *decl = 0;
 
1688
    parseAbstractDeclarator(decl);
 
1689
 
 
1690
    TypeIdAST *ast = CreateNode<TypeIdAST>(m_pool);
 
1691
    ast->setTypeSpecifier(spec);
 
1692
    ast->setDeclarator(decl);
 
1693
 
 
1694
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1695
    node = ast;
 
1696
 
 
1697
    return true;
 
1698
}
 
1699
 
 
1700
bool Parser::parseInitDeclaratorList(InitDeclaratorListAST *&node)
 
1701
{
 
1702
    int start = tokenStream->cursor();
 
1703
 
 
1704
    InitDeclaratorListAST *ast = CreateNode<InitDeclaratorListAST>(m_pool);
 
1705
    InitDeclaratorAST *decl = 0;
 
1706
 
 
1707
    if (!parseInitDeclarator(decl)) {
 
1708
        return false;
 
1709
    }
 
1710
    ast->addInitDeclarator(decl);
 
1711
 
 
1712
    while (tokenStream->lookAhead() == ',') {
 
1713
        advance();
 
1714
 
 
1715
        if (!parseInitDeclarator(decl)) {
 
1716
            syntaxError();
 
1717
            break;
 
1718
        }
 
1719
        ast->addInitDeclarator(decl);
 
1720
    }
 
1721
 
 
1722
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1723
    node = ast;
 
1724
 
 
1725
    return true;
 
1726
}
 
1727
 
 
1728
bool Parser::parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node)
 
1729
{
 
1730
    int start = tokenStream->cursor();
 
1731
 
 
1732
    ParameterDeclarationClauseAST *ast = CreateNode<ParameterDeclarationClauseAST>(m_pool);
 
1733
 
 
1734
    ParameterDeclarationListAST *params = 0;
 
1735
    if (!parseParameterDeclarationList(params)) {
 
1736
 
 
1737
        if (tokenStream->lookAhead() == ')')
 
1738
            goto good;
 
1739
 
 
1740
        if (tokenStream->lookAhead() == Token_ellipsis && tokenStream->lookAhead(1) == ')') {
 
1741
            AST_FROM_TOKEN(ellipsis, tokenStream->cursor());
 
1742
            ast->setEllipsis(ellipsis);
 
1743
            advance();
 
1744
            goto good;
 
1745
        }
 
1746
        return false;
 
1747
    }
 
1748
 
 
1749
    if (tokenStream->lookAhead() == Token_ellipsis) {
 
1750
        AST_FROM_TOKEN(ellipsis, tokenStream->cursor());
 
1751
        ast->setEllipsis(ellipsis);
 
1752
        advance();
 
1753
    }
 
1754
 
 
1755
good:
 
1756
    ast->setParameterDeclarationList(params);
 
1757
 
 
1758
    /// @todo add ellipsis
 
1759
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1760
    node = ast;
 
1761
 
 
1762
    return true;
 
1763
}
 
1764
 
 
1765
bool Parser::parseParameterDeclarationList(ParameterDeclarationListAST *&node)
 
1766
{
 
1767
    int start = tokenStream->cursor();
 
1768
 
 
1769
    ParameterDeclarationListAST *ast = CreateNode<ParameterDeclarationListAST>(m_pool);
 
1770
 
 
1771
    ParameterDeclarationAST *param = 0;
 
1772
    if (!parseParameterDeclaration(param)) {
 
1773
        tokenStream->rewind(start);
 
1774
        return false;
 
1775
    }
 
1776
    ast->addParameter(param);
 
1777
 
 
1778
    while (tokenStream->lookAhead() == ',') {
 
1779
        advance();
 
1780
 
 
1781
        if (tokenStream->lookAhead() == Token_ellipsis)
 
1782
            break;
 
1783
 
 
1784
        if (!parseParameterDeclaration(param)) {
 
1785
            tokenStream->rewind(start);
 
1786
            return false;
 
1787
        }
 
1788
        ast->addParameter(param);
 
1789
    }
 
1790
 
 
1791
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1792
    node = ast;
 
1793
 
 
1794
    return true;
 
1795
}
 
1796
 
 
1797
bool Parser::parseParameterDeclaration(ParameterDeclarationAST *&node)
 
1798
{
 
1799
    int start = tokenStream->cursor();
 
1800
 
 
1801
    AST *storage = 0;
 
1802
    parseStorageClassSpecifier(storage);
 
1803
 
 
1804
    // parse decl spec
 
1805
    TypeSpecifierAST *spec = 0;
 
1806
    if (!parseTypeSpecifier(spec)) {
 
1807
        tokenStream->rewind(start);
 
1808
        return false;
 
1809
    }
 
1810
 
 
1811
    int index = tokenStream->cursor();
 
1812
 
 
1813
    DeclaratorAST *decl = 0;
 
1814
    if (!parseDeclarator(decl)) {
 
1815
        tokenStream->rewind(index);
 
1816
 
 
1817
        // try with abstract declarator
 
1818
        parseAbstractDeclarator(decl);
 
1819
    }
 
1820
 
 
1821
    AbstractExpressionAST *expr = 0;
 
1822
    if (tokenStream->lookAhead() == '=') {
 
1823
        advance();
 
1824
        if (!parseLogicalOrExpression(expr,true)) {
 
1825
            //reportError(i18n("Expression expected"));
 
1826
        }
 
1827
    }
 
1828
 
 
1829
    ParameterDeclarationAST *ast = CreateNode<ParameterDeclarationAST>(m_pool);
 
1830
    ast->setTypeSpec(spec);
 
1831
    ast->setDeclarator(decl);
 
1832
    ast->setExpression(expr);
 
1833
 
 
1834
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1835
    node = ast;
 
1836
 
 
1837
    return true;
 
1838
}
 
1839
 
 
1840
bool Parser::parseClassSpecifier(TypeSpecifierAST *&node)
 
1841
{
 
1842
    int start = tokenStream->cursor();
 
1843
 
 
1844
    AST *classKey = 0;
 
1845
    int classKeyStart = tokenStream->cursor();
 
1846
 
 
1847
    int kind = tokenStream->lookAhead();
 
1848
    if (kind == Token_class || kind == Token_struct || kind == Token_union) {
 
1849
        AST *asn = CreateNode<AST>(m_pool);
 
1850
        classKey = asn;
 
1851
        advance();
 
1852
        UPDATE_POS(classKey, classKeyStart, tokenStream->cursor());
 
1853
    } else {
 
1854
        return false;
 
1855
    }
 
1856
 
 
1857
    AST *winDeclSpec = 0;
 
1858
    parseWinDeclSpec(winDeclSpec);
 
1859
 
 
1860
    while (tokenStream->lookAhead() == Token_identifier && tokenStream->lookAhead(1) == Token_identifier)
 
1861
            advance();
 
1862
 
 
1863
    NameAST *name = 0;
 
1864
    parseName(name);
 
1865
 
 
1866
    BaseClauseAST *bases = 0;
 
1867
    if (tokenStream->lookAhead() == ':') {
 
1868
        if (!parseBaseClause(bases)) {
 
1869
            skipUntil('{');
 
1870
        }
 
1871
    }
 
1872
 
 
1873
    if (tokenStream->lookAhead() != '{') {
 
1874
        tokenStream->rewind(start);
 
1875
        return false;
 
1876
    }
 
1877
 
 
1878
    ADVANCE('{', '{');
 
1879
 
 
1880
    ClassSpecifierAST *ast = CreateNode<ClassSpecifierAST>(m_pool);
 
1881
    ast->setWinDeclSpec(winDeclSpec);
 
1882
    ast->setClassKey(classKey);
 
1883
    ast->setName(name);
 
1884
    ast->setBaseClause(bases);
 
1885
 
 
1886
    while (tokenStream->lookAhead()) {
 
1887
        if (tokenStream->lookAhead() == '}')
 
1888
            break;
 
1889
 
 
1890
        DeclarationAST *memSpec = 0;
 
1891
        int startDecl = tokenStream->cursor();
 
1892
        if (!parseMemberSpecification(memSpec)) {
 
1893
            if (startDecl == tokenStream->cursor())
 
1894
                advance(); // skip at least one token
 
1895
            skipUntilDeclaration();
 
1896
        } else
 
1897
            ast->addDeclaration(memSpec);
 
1898
    }
 
1899
 
 
1900
    if (tokenStream->lookAhead() != '}') {
 
1901
        reportError(i18n("} missing"));
 
1902
    } else
 
1903
        advance();
 
1904
 
 
1905
    UPDATE_POS(ast, start, tokenStream->cursor());
 
1906
    node = ast;
 
1907
 
 
1908
    return true;
 
1909
}
 
1910
 
 
1911
bool Parser::parseAccessSpecifier(AST *&node)
 
1912
{
 
1913
    int start = tokenStream->cursor();
 
1914
 
 
1915
    switch(tokenStream->lookAhead()) {
 
1916
    case Token_public:
 
1917
    case Token_protected:
 
1918
    case Token_private: {
 
1919
        AST *asn = CreateNode<AST>(m_pool);
 
1920
        node = asn;
 
1921
        advance();
 
1922
        UPDATE_POS(node, start, tokenStream->cursor());
 
1923
        return true;
 
1924
        }
 
1925
    }
 
1926
 
 
1927
    return false;
 
1928
}
 
1929
 
 
1930
bool Parser::parseMemberSpecification(DeclarationAST *&node)
 
1931
{
 
1932
    int start = tokenStream->cursor();
 
1933
 
 
1934
    AST *access = 0;
 
1935
 
 
1936
    if (tokenStream->lookAhead() == ';') {
 
1937
        advance();
 
1938
        return true;
 
1939
    } else if (tokenStream->lookAhead() == Token_Q_OBJECT || tokenStream->lookAhead() == Token_K_DCOP) {
 
1940
        advance();
 
1941
        return true;
 
1942
    } else if (tokenStream->lookAhead() == Token_signals
 
1943
            || tokenStream->lookAhead() == Token_k_dcop
 
1944
            || tokenStream->lookAhead() == Token_k_dcop_signals) {
 
1945
        AccessDeclarationAST *ast = CreateNode<AccessDeclarationAST>(m_pool);
 
1946
        advance();
 
1947
        AST *n = CreateNode<AST>(m_pool);
 
1948
        UPDATE_POS(n, start, tokenStream->cursor());
 
1949
        ast->addAccess(n);
 
1950
        ADVANCE(':', ":");
 
1951
        UPDATE_POS(ast, start, tokenStream->cursor());
 
1952
        node = ast;
 
1953
        return true;
 
1954
    } else if (parseTypedef(node)) {
 
1955
        return true;
 
1956
    } else if (parseUsing(node)) {
 
1957
        return true;
 
1958
    } else if (parseTemplateDeclaration(node)) {
 
1959
        return true;
 
1960
    } else if (parseAccessSpecifier(access)) {
 
1961
        AccessDeclarationAST *ast = CreateNode<AccessDeclarationAST>(m_pool);
 
1962
        ast->addAccess(access);
 
1963
 
 
1964
        int startSlot = tokenStream->cursor();
 
1965
        if (tokenStream->lookAhead() == Token_slots) {
 
1966
            advance();
 
1967
            AST *sl = CreateNode<AST>(m_pool);
 
1968
            UPDATE_POS(sl, startSlot, tokenStream->cursor());
 
1969
            ast->addAccess(sl);
 
1970
        }
 
1971
        ADVANCE(':', ":");
 
1972
        UPDATE_POS(ast, start, tokenStream->cursor());
 
1973
        node = ast;
 
1974
        return true;
 
1975
    }
 
1976
 
 
1977
    tokenStream->rewind(start);
 
1978
 
 
1979
    AST *storageSpec = 0;
 
1980
    parseStorageClassSpecifier(storageSpec);
 
1981
 
 
1982
    AST *cv = 0;
 
1983
    parseCvQualify(cv);
 
1984
 
 
1985
    TypeSpecifierAST *spec = 0;
 
1986
    if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) {
 
1987
        spec->setCvQualify(cv);
 
1988
 
 
1989
        AST *cv2 = 0;
 
1990
        parseCvQualify(cv2);
 
1991
        spec->setCv2Qualify(cv2);
 
1992
 
 
1993
            InitDeclaratorListAST *declarators = 0;
 
1994
        parseInitDeclaratorList(declarators);
 
1995
        ADVANCE(';', ";");
 
1996
 
 
1997
        SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool);
 
1998
        ast->setTypeSpec(spec);
 
1999
        ast->setInitDeclaratorList(declarators);
 
2000
        UPDATE_POS(ast, start, tokenStream->cursor());
 
2001
        node = ast;
 
2002
 
 
2003
        return true;
 
2004
    }
 
2005
 
 
2006
    tokenStream->rewind(start);
 
2007
    return parseDeclarationInternal(node);
 
2008
}
 
2009
 
 
2010
bool Parser::parseCtorInitializer(AST *&/*node*/)
 
2011
{
 
2012
    if (tokenStream->lookAhead() != ':') {
 
2013
        return false;
 
2014
    }
 
2015
    advance();
 
2016
 
 
2017
    AST *inits = 0;
 
2018
    if (!parseMemInitializerList(inits)) {
 
2019
        reportError(i18n("Member initializers expected"));
 
2020
    }
 
2021
 
 
2022
    return true;
 
2023
}
 
2024
 
 
2025
bool Parser::parseElaboratedTypeSpecifier(TypeSpecifierAST *&node)
 
2026
{
 
2027
    int start = tokenStream->cursor();
 
2028
 
 
2029
    int tk = tokenStream->lookAhead();
 
2030
    if (tk == Token_class  ||
 
2031
        tk == Token_struct ||
 
2032
        tk == Token_union  ||
 
2033
        tk == Token_enum   ||
 
2034
        tk == Token_typename)
 
2035
    {
 
2036
        AST *kind = CreateNode<AST>(m_pool);
 
2037
        advance();
 
2038
        UPDATE_POS(kind, start, tokenStream->cursor());
 
2039
 
 
2040
        NameAST *name = 0;
 
2041
 
 
2042
        if (parseName(name)) {
 
2043
            ElaboratedTypeSpecifierAST *ast = CreateNode<ElaboratedTypeSpecifierAST>(m_pool);
 
2044
            ast->setKind(kind);
 
2045
            ast->setName(name);
 
2046
            UPDATE_POS(ast, start, tokenStream->cursor());
 
2047
            node = ast;
 
2048
 
 
2049
            return true;
 
2050
        }
 
2051
    }
 
2052
 
 
2053
    tokenStream->rewind(start);
 
2054
    return false;
 
2055
}
 
2056
 
 
2057
bool Parser::parseDeclaratorId(NameAST *&node)
 
2058
{
 
2059
    return parseName(node);
 
2060
}
 
2061
 
 
2062
bool Parser::parseExceptionSpecification(AST *&node)
 
2063
{
 
2064
    if (tokenStream->lookAhead() != Token_throw) {
 
2065
        return false;
 
2066
    }
 
2067
    advance();
 
2068
 
 
2069
    ADVANCE('(', "(");
 
2070
    if (tokenStream->lookAhead() == Token_ellipsis) {
 
2071
        // extension found in MSVC++ 7.x headers
 
2072
        int start = tokenStream->cursor();
 
2073
        AST *ast = CreateNode<AST>(m_pool);
 
2074
        AST_FROM_TOKEN(ellipsis, tokenStream->cursor());
 
2075
        ellipsis->setParent(ast);
 
2076
        advance();
 
2077
        UPDATE_POS(ast, start, tokenStream->cursor());
 
2078
        node = ast;
 
2079
    } else {
 
2080
        parseTypeIdList(node);
 
2081
    }
 
2082
    ADVANCE(')', ")");
 
2083
 
 
2084
    return true;
 
2085
}
 
2086
 
 
2087
bool Parser::parseEnumerator(EnumeratorAST *&node)
 
2088
{
 
2089
    int start = tokenStream->cursor();
 
2090
 
 
2091
    if (tokenStream->lookAhead() != Token_identifier) {
 
2092
        return false;
 
2093
    }
 
2094
    advance();
 
2095
 
 
2096
    EnumeratorAST *ena = CreateNode<EnumeratorAST>(m_pool);
 
2097
    node = ena;
 
2098
 
 
2099
    AST *id = CreateNode<AST>(m_pool);
 
2100
    UPDATE_POS(id, start, tokenStream->cursor());
 
2101
    node->setId(id);
 
2102
 
 
2103
    if (tokenStream->lookAhead() == '=') {
 
2104
        advance();
 
2105
 
 
2106
        AbstractExpressionAST *expr = 0;
 
2107
        if (!parseConstantExpression(expr)) {
 
2108
            reportError(i18n("Constant expression expected"));
 
2109
        }
 
2110
        node->setExpression(expr);
 
2111
    }
 
2112
 
 
2113
    UPDATE_POS(node, start, tokenStream->cursor());
 
2114
 
 
2115
    return true;
 
2116
}
 
2117
 
 
2118
bool Parser::parseInitDeclarator(InitDeclaratorAST *&node)
 
2119
{
 
2120
    int start = tokenStream->cursor();
 
2121
 
 
2122
    DeclaratorAST *decl = 0;
 
2123
    AST *init = 0;
 
2124
    if (!parseDeclarator(decl)) {
 
2125
        return false;
 
2126
    }
 
2127
 
 
2128
    parseInitializer(init);
 
2129
 
 
2130
    InitDeclaratorAST *ast = CreateNode<InitDeclaratorAST>(m_pool);
 
2131
    ast->setDeclarator(decl);
 
2132
    ast->setInitializer(init);
 
2133
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2134
    node = ast;
 
2135
 
 
2136
    return true;
 
2137
}
 
2138
 
 
2139
 
 
2140
 
 
2141
bool Parser::parseBaseClause(BaseClauseAST *&node)
 
2142
{
 
2143
    int start = tokenStream->cursor();
 
2144
    if (tokenStream->lookAhead() != ':') {
 
2145
        return false;
 
2146
    }
 
2147
    advance();
 
2148
 
 
2149
    BaseClauseAST *bca = CreateNode<BaseClauseAST>(m_pool);
 
2150
 
 
2151
    BaseSpecifierAST *baseSpec = 0;
 
2152
    if (parseBaseSpecifier(baseSpec)) {
 
2153
        bca->addBaseSpecifier(baseSpec);
 
2154
 
 
2155
        while (tokenStream->lookAhead() == ',') {
 
2156
            advance();
 
2157
 
 
2158
            if (!parseBaseSpecifier(baseSpec)) {
 
2159
                reportError(i18n("Base class specifier expected"));
 
2160
                return false;
 
2161
            }
 
2162
            bca->addBaseSpecifier(baseSpec);
 
2163
        }
 
2164
    } else
 
2165
        return false;
 
2166
 
 
2167
    UPDATE_POS(bca, start, tokenStream->cursor());
 
2168
    node = bca;
 
2169
 
 
2170
    return true;
 
2171
}
 
2172
 
 
2173
bool Parser::parseInitializer(AST *&node)
 
2174
{
 
2175
    if (tokenStream->lookAhead() == '=') {
 
2176
        advance();
 
2177
 
 
2178
        if (!parseInitializerClause(node)) {
 
2179
            reportError(i18n("Initializer clause expected"));
 
2180
            return false;
 
2181
        }
 
2182
        return true;
 
2183
    } else if (tokenStream->lookAhead() == '(') {
 
2184
        advance();
 
2185
        AbstractExpressionAST *expr = 0;
 
2186
        skipCommaExpression(expr);
 
2187
        CHECK(')', ")");
 
2188
        node = expr;
 
2189
        return true;
 
2190
    }
 
2191
 
 
2192
    return false;
 
2193
}
 
2194
 
 
2195
bool Parser::parseMemInitializerList(AST *&/*node*/)
 
2196
{
 
2197
    AST *init = 0;
 
2198
    if (!parseMemInitializer(init)) {
 
2199
        return false;
 
2200
    }
 
2201
 
 
2202
    while (tokenStream->lookAhead() == ',') {
 
2203
        advance();
 
2204
 
 
2205
        if (!parseMemInitializer(init)) {
 
2206
            break;
 
2207
        }
 
2208
    }
 
2209
 
 
2210
    return true;
 
2211
}
 
2212
 
 
2213
bool Parser::parseMemInitializer(AST *&/*node*/)
 
2214
{
 
2215
    NameAST *initId = 0;
 
2216
    if (!parseMemInitializerId(initId)) {
 
2217
        reportError(i18n("Identifier expected"));
 
2218
        return false;
 
2219
    }
 
2220
    ADVANCE('(', '(');
 
2221
    AbstractExpressionAST *expr = 0;
 
2222
    skipCommaExpression(expr);
 
2223
    ADVANCE(')', ')');
 
2224
 
 
2225
    return true;
 
2226
}
 
2227
 
 
2228
bool Parser::parseTypeIdList(AST *&node)
 
2229
{
 
2230
 
 
2231
    int start = tokenStream->cursor();
 
2232
 
 
2233
    TypeIdAST *typeId = 0;
 
2234
    if (!parseTypeId(typeId)) {
 
2235
        return false;
 
2236
    }
 
2237
 
 
2238
    AST *ast = CreateNode<AST>(m_pool);
 
2239
    typeId->setParent(ast);
 
2240
 
 
2241
    while (tokenStream->lookAhead() == ',') {
 
2242
        advance();
 
2243
        if (parseTypeId(typeId)) {
 
2244
            typeId->setParent(ast);
 
2245
        } else {
 
2246
            reportError(i18n("Type id expected"));
 
2247
            break;
 
2248
        }
 
2249
    }
 
2250
 
 
2251
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2252
    node = ast;
 
2253
    return true;
 
2254
}
 
2255
 
 
2256
bool Parser::parseBaseSpecifier(BaseSpecifierAST *&node)
 
2257
{
 
2258
    int start = tokenStream->cursor();
 
2259
    BaseSpecifierAST *ast = CreateNode<BaseSpecifierAST>(m_pool);
 
2260
 
 
2261
    AST *access = 0;
 
2262
    if (tokenStream->lookAhead() == Token_virtual) {
 
2263
        AST_FROM_TOKEN(virt, tokenStream->cursor());
 
2264
        ast->setIsVirtual(virt);
 
2265
 
 
2266
        advance();
 
2267
 
 
2268
        parseAccessSpecifier(access);
 
2269
    } else {
 
2270
        parseAccessSpecifier(access);
 
2271
 
 
2272
        if (tokenStream->lookAhead() == Token_virtual) {
 
2273
            AST_FROM_TOKEN(virt, tokenStream->cursor());
 
2274
            ast->setIsVirtual(virt);
 
2275
            advance();
 
2276
        }
 
2277
    }
 
2278
 
 
2279
    NameAST *name = 0;
 
2280
    if (!parseName(name)) {
 
2281
        reportError(i18n("Class name expected"));
 
2282
    }
 
2283
 
 
2284
    ast->setAccess(access);
 
2285
    ast->setName(name);
 
2286
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2287
    node = ast;
 
2288
 
 
2289
    return true;
 
2290
}
 
2291
 
 
2292
 
 
2293
bool Parser::parseInitializerClause(AST *&node)
 
2294
{
 
2295
    if (tokenStream->lookAhead() == '{') {
 
2296
        if (!skip('{','}')) {
 
2297
            reportError(i18n("} missing"));
 
2298
        } else
 
2299
            advance();
 
2300
    } else {
 
2301
        AbstractExpressionAST *expr = 0;
 
2302
        if (!parseAssignmentExpression(expr)) {
 
2303
            //reportError(i18n("Expression expected"));
 
2304
        }
 
2305
        node = expr;
 
2306
    }
 
2307
 
 
2308
    return true;
 
2309
}
 
2310
 
 
2311
bool Parser::parseMemInitializerId(NameAST *&node)
 
2312
{
 
2313
 
 
2314
    return parseName(node);
 
2315
}
 
2316
 
 
2317
bool Parser::parsePtrToMember(AST *&/*node*/)     /// ### create the AST node
 
2318
{
 
2319
    int start = tokenStream->cursor();
 
2320
 
 
2321
    if (tokenStream->lookAhead() == Token_scope)
 
2322
        advance();
 
2323
 
 
2324
    ClassOrNamespaceNameAST *name = 0;
 
2325
    while (tokenStream->lookAhead() == Token_identifier) {
 
2326
 
 
2327
        if (!parseUnqualifiedName(name))
 
2328
            break;
 
2329
 
 
2330
        if (tokenStream->lookAhead() == Token_scope
 
2331
                && tokenStream->lookAhead(1) == '*') {
 
2332
            advance();
 
2333
            advance();
 
2334
            return true;
 
2335
        }
 
2336
 
 
2337
        if (tokenStream->lookAhead() == Token_scope)
 
2338
            advance();
 
2339
    }
 
2340
 
 
2341
    tokenStream->rewind(start);
 
2342
    return false;
 
2343
}
 
2344
 
 
2345
bool Parser::parseUnqualifiedName(ClassOrNamespaceNameAST *&node, bool parseTemplateId)
 
2346
{
 
2347
    int start = tokenStream->cursor();
 
2348
    bool isDestructor = false;
 
2349
 
 
2350
    ClassOrNamespaceNameAST *ast = CreateNode<ClassOrNamespaceNameAST>(m_pool);
 
2351
 
 
2352
    if (tokenStream->lookAhead() == Token_identifier) {
 
2353
        int startName = tokenStream->cursor();
 
2354
        AST *n = CreateNode<AST>(m_pool);
 
2355
        advance();
 
2356
        UPDATE_POS(n, startName, tokenStream->cursor());
 
2357
        ast->setName(n);
 
2358
    } else if (tokenStream->lookAhead() == '~' && tokenStream->lookAhead(1) == Token_identifier) {
 
2359
        int startName = tokenStream->cursor();
 
2360
        AST *n = CreateNode<AST>(m_pool);
 
2361
        advance(); // skip ~
 
2362
        advance(); // skip classname
 
2363
        UPDATE_POS(n, startName, tokenStream->cursor());
 
2364
        ast->setName(n);
 
2365
        isDestructor = true;
 
2366
    } else if (tokenStream->lookAhead() == Token_operator) {
 
2367
        AST *n = 0;
 
2368
        if (!parseOperatorFunctionId(n))
 
2369
            return false;
 
2370
        ast->setName(n);
 
2371
    } else {
 
2372
        return false;
 
2373
    }
 
2374
 
 
2375
    if (parseTemplateId && !isDestructor) {
 
2376
 
 
2377
        int index = tokenStream->cursor();
 
2378
 
 
2379
        if (tokenStream->lookAhead() == '<') {
 
2380
            advance();
 
2381
 
 
2382
            // optional template arguments
 
2383
            TemplateArgumentListAST *args = 0;
 
2384
            parseTemplateArgumentList(args);
 
2385
 
 
2386
            if (tokenStream->lookAhead() != '>') {
 
2387
                tokenStream->rewind(index);
 
2388
            } else {
 
2389
                advance();
 
2390
                ast->setTemplateArgumentList(args);
 
2391
            }
 
2392
        }
 
2393
    }
 
2394
 
 
2395
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2396
    node = ast;
 
2397
 
 
2398
    return true;
 
2399
}
 
2400
 
 
2401
bool Parser::parseStringLiteral(AST *&node)
 
2402
{
 
2403
    int start = tokenStream->cursor();
 
2404
 
 
2405
    while (tokenStream->lookAhead()) {
 
2406
        if (tokenStream->lookAhead() == Token_identifier &&
 
2407
            tokenStream->currentTokenText() == "L" && tokenStream->lookAhead(1) == Token_string_literal) {
 
2408
 
 
2409
            advance();
 
2410
            advance();
 
2411
        } else if (tokenStream->lookAhead() == Token_string_literal) {
 
2412
            advance();
 
2413
        } else
 
2414
            return false;
 
2415
    }
 
2416
 
 
2417
    AST *ast = CreateNode<AST>(m_pool);
 
2418
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2419
    node = ast;
 
2420
    return true;
 
2421
}
 
2422
 
 
2423
bool Parser::skipExpressionStatement(StatementAST *&node)
 
2424
{
 
2425
    int start = tokenStream->cursor();
 
2426
 
 
2427
    AbstractExpressionAST *expr = 0;
 
2428
    skipCommaExpression(expr);
 
2429
 
 
2430
    ADVANCE(';', ";");
 
2431
 
 
2432
    ExpressionStatementAST *ast = CreateNode<ExpressionStatementAST>(m_pool);
 
2433
    ast->setExpression(expr);
 
2434
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2435
    node = ast;
 
2436
 
 
2437
    return true;
 
2438
}
 
2439
 
 
2440
bool Parser::parseStatement(StatementAST *&node)
 
2441
{
 
2442
    int start = tokenStream->cursor();
 
2443
 
 
2444
    switch(tokenStream->lookAhead()) {
 
2445
 
 
2446
    case Token_while:
 
2447
        return parseWhileStatement(node);
 
2448
 
 
2449
    case Token_do:
 
2450
        return parseDoStatement(node);
 
2451
 
 
2452
    case Token_for:
 
2453
        return parseForStatement(node);
 
2454
 
 
2455
    case Token_if:
 
2456
        return parseIfStatement(node);
 
2457
 
 
2458
    case Token_switch:
 
2459
        return parseSwitchStatement(node);
 
2460
 
 
2461
    case Token_try:
 
2462
        return parseTryBlockStatement(node);
 
2463
 
 
2464
    case Token_case:
 
2465
    case Token_default:
 
2466
        return parseLabeledStatement(node);
 
2467
 
 
2468
    case Token_break:
 
2469
    case Token_continue:
 
2470
        advance();
 
2471
        ADVANCE(';', ";");
 
2472
        return true;
 
2473
 
 
2474
    case Token_goto:
 
2475
        advance();
 
2476
        ADVANCE(Token_identifier, "identifier");
 
2477
        ADVANCE(';', ";");
 
2478
        return true;
 
2479
 
 
2480
    case Token_return:
 
2481
    {
 
2482
        advance();
 
2483
        AbstractExpressionAST *expr = 0;
 
2484
        skipCommaExpression(expr);
 
2485
 
 
2486
        ADVANCE(';', ";");
 
2487
 
 
2488
        ReturnStatementAST *ast = CreateNode<ReturnStatementAST>(m_pool);
 
2489
        ast->setExpression(expr);
 
2490
        UPDATE_POS(ast, start, tokenStream->cursor());
 
2491
        node = ast;
 
2492
    }
 
2493
    return true;
 
2494
 
 
2495
    case '{':
 
2496
        return parseCompoundStatement(node);
 
2497
 
 
2498
    case Token_identifier:
 
2499
        if (parseLabeledStatement(node))
 
2500
            return true;
 
2501
        break;
 
2502
    }
 
2503
 
 
2504
    if (parseDeclarationStatement(node))
 
2505
        return true;
 
2506
 
 
2507
    return skipExpressionStatement(node);
 
2508
}
 
2509
 
 
2510
bool Parser::parseCondition(ConditionAST *&node)
 
2511
{
 
2512
    int start = tokenStream->cursor();
 
2513
 
 
2514
    ConditionAST *ast = CreateNode<ConditionAST>(m_pool);
 
2515
    TypeSpecifierAST *spec = 0;
 
2516
 
 
2517
    if (parseTypeSpecifier(spec)) {
 
2518
        DeclaratorAST *decl = 0;
 
2519
        if (parseDeclarator(decl) && tokenStream->lookAhead() == '=') {
 
2520
            advance();
 
2521
 
 
2522
            AbstractExpressionAST *expr = 0;
 
2523
            if (parseExpression(expr)) {
 
2524
                ast->setTypeSpec(spec);
 
2525
                ast->setDeclarator(decl);
 
2526
                ast->setExpression(expr);
 
2527
 
 
2528
                UPDATE_POS(ast, start, tokenStream->cursor());
 
2529
                node = ast;
 
2530
 
 
2531
                return true;
 
2532
            }
 
2533
        }
 
2534
    }
 
2535
 
 
2536
    tokenStream->rewind(start);
 
2537
 
 
2538
    AbstractExpressionAST *expr = 0;
 
2539
    if (!skipCommaExpression(expr)) {
 
2540
        return false;
 
2541
    }
 
2542
 
 
2543
    ast->setExpression(expr);
 
2544
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2545
    node = ast;
 
2546
    return true;
 
2547
}
 
2548
 
 
2549
 
 
2550
bool Parser::parseWhileStatement(StatementAST *&node)
 
2551
{
 
2552
    int start = tokenStream->cursor();
 
2553
 
 
2554
    ADVANCE(Token_while, "while");
 
2555
    ADVANCE('(' , "(");
 
2556
 
 
2557
    ConditionAST *cond = 0;
 
2558
    if (!parseCondition(cond)) {
 
2559
        reportError(i18n("condition expected"));
 
2560
        return false;
 
2561
    }
 
2562
    ADVANCE(')', ")");
 
2563
 
 
2564
    StatementAST *body = 0;
 
2565
    if (!parseStatement(body)) {
 
2566
        reportError(i18n("statement expected"));
 
2567
        return false;
 
2568
    }
 
2569
 
 
2570
    WhileStatementAST *ast = CreateNode<WhileStatementAST>(m_pool);
 
2571
    ast->setCondition(cond);
 
2572
    ast->setStatement(body);
 
2573
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2574
    node = ast;
 
2575
 
 
2576
    return true;
 
2577
}
 
2578
 
 
2579
bool Parser::parseDoStatement(StatementAST *&node)
 
2580
{
 
2581
    int start = tokenStream->cursor();
 
2582
 
 
2583
    ADVANCE(Token_do, "do");
 
2584
 
 
2585
    StatementAST *body = 0;
 
2586
    if (!parseStatement(body)) {
 
2587
        reportError(i18n("statement expected"));
 
2588
        //return false;
 
2589
    }
 
2590
 
 
2591
    ADVANCE_NR(Token_while, "while");
 
2592
    ADVANCE_NR('(' , "(");
 
2593
 
 
2594
    AbstractExpressionAST *expr = 0;
 
2595
    if (!skipCommaExpression(expr)) {
 
2596
        reportError(i18n("expression expected"));
 
2597
        //return false;
 
2598
    }
 
2599
 
 
2600
    ADVANCE_NR(')', ")");
 
2601
    ADVANCE_NR(';', ";");
 
2602
 
 
2603
    DoStatementAST *ast = CreateNode<DoStatementAST>(m_pool);
 
2604
    ast->setStatement(body);
 
2605
    //ast->setCondition(condition);
 
2606
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2607
    node = ast;
 
2608
 
 
2609
    return true;
 
2610
}
 
2611
 
 
2612
bool Parser::parseForStatement(StatementAST *&node)
 
2613
{
 
2614
    int start = tokenStream->cursor();
 
2615
 
 
2616
    ADVANCE(Token_for, "for");
 
2617
    ADVANCE('(', "(");
 
2618
 
 
2619
    StatementAST *init = 0;
 
2620
    if (!parseForInitStatement(init)) {
 
2621
        reportError(i18n("for initialization expected"));
 
2622
        return false;
 
2623
    }
 
2624
 
 
2625
    ConditionAST *cond = 0;
 
2626
    parseCondition(cond);
 
2627
    ADVANCE(';', ";");
 
2628
 
 
2629
    AbstractExpressionAST *expr = 0;
 
2630
    skipCommaExpression(expr);
 
2631
    ADVANCE(')', ")");
 
2632
 
 
2633
    StatementAST *body = 0;
 
2634
    if (!parseStatement(body))
 
2635
        return false;
 
2636
 
 
2637
    ForStatementAST *ast = CreateNode<ForStatementAST>(m_pool);
 
2638
    ast->setInitStatement(init);
 
2639
    ast->setCondition(cond);
 
2640
    // ast->setExpression(expression);
 
2641
    ast->setStatement(body);
 
2642
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2643
    node = ast;
 
2644
 
 
2645
    return true;
 
2646
}
 
2647
 
 
2648
bool Parser::parseForInitStatement(StatementAST *&node)
 
2649
{
 
2650
    if (parseDeclarationStatement(node))
 
2651
        return true;
 
2652
 
 
2653
    return skipExpressionStatement(node);
 
2654
}
 
2655
 
 
2656
bool Parser::parseCompoundStatement(StatementAST *&node)
 
2657
{
 
2658
    int start = tokenStream->cursor();
 
2659
 
 
2660
    if (tokenStream->lookAhead() != '{') {
 
2661
        return false;
 
2662
    }
 
2663
    advance();
 
2664
 
 
2665
    StatementListAST *ast = CreateNode<StatementListAST>(m_pool);
 
2666
 
 
2667
    while (tokenStream->lookAhead()) {
 
2668
        if (tokenStream->lookAhead() == '}')
 
2669
            break;
 
2670
 
 
2671
        StatementAST *stmt = 0;
 
2672
        int startStmt = tokenStream->cursor();
 
2673
        if (!parseStatement(stmt)) {
 
2674
            if (startStmt == tokenStream->cursor())
 
2675
                advance();
 
2676
            skipUntilStatement();
 
2677
        } else {
 
2678
            ast->addStatement(stmt);
 
2679
        }
 
2680
    }
 
2681
 
 
2682
    if (tokenStream->lookAhead() != '}') {
 
2683
        reportError(i18n("} expected"));
 
2684
    } else {
 
2685
        advance();
 
2686
    }
 
2687
 
 
2688
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2689
    node = ast;
 
2690
 
 
2691
    return true;
 
2692
}
 
2693
 
 
2694
bool Parser::parseIfStatement(StatementAST *&node)
 
2695
{
 
2696
    int start = tokenStream->cursor();
 
2697
 
 
2698
    ADVANCE(Token_if, "if");
 
2699
 
 
2700
    ADVANCE('(' , "(");
 
2701
 
 
2702
    IfStatementAST *ast = CreateNode<IfStatementAST>(m_pool);
 
2703
 
 
2704
    ConditionAST *cond = 0;
 
2705
    if (!parseCondition(cond)) {
 
2706
        reportError(i18n("condition expected"));
 
2707
        return false;
 
2708
    }
 
2709
    ADVANCE(')', ")");
 
2710
 
 
2711
    StatementAST *stmt = 0;
 
2712
    if (!parseStatement(stmt)) {
 
2713
        reportError(i18n("statement expected"));
 
2714
        return false;
 
2715
    }
 
2716
 
 
2717
    ast->setCondition(cond);
 
2718
    ast->setStatement(stmt);
 
2719
 
 
2720
    if (tokenStream->lookAhead() == Token_else) {
 
2721
        advance();
 
2722
        StatementAST *elseStmt = 0;
 
2723
        if (!parseStatement(elseStmt)) {
 
2724
            reportError(i18n("statement expected"));
 
2725
            return false;
 
2726
        }
 
2727
        ast->setElseStatement(elseStmt);
 
2728
    }
 
2729
 
 
2730
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2731
    node = ast;
 
2732
 
 
2733
    return true;
 
2734
}
 
2735
 
 
2736
bool Parser::parseSwitchStatement(StatementAST *&node)
 
2737
{
 
2738
    int start = tokenStream->cursor();
 
2739
    ADVANCE(Token_switch, "switch");
 
2740
 
 
2741
    ADVANCE('(' , "(");
 
2742
 
 
2743
    ConditionAST *cond = 0;
 
2744
    if (!parseCondition(cond)) {
 
2745
        reportError(i18n("condition expected"));
 
2746
        return false;
 
2747
    }
 
2748
    ADVANCE(')', ")");
 
2749
 
 
2750
    StatementAST *stmt = 0;
 
2751
    if (!parseCompoundStatement(stmt)) {
 
2752
        syntaxError();
 
2753
        return false;
 
2754
    }
 
2755
 
 
2756
    SwitchStatementAST *ast = CreateNode<SwitchStatementAST>(m_pool);
 
2757
    ast->setCondition(cond);
 
2758
    ast->setStatement(stmt);
 
2759
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2760
    node = ast;
 
2761
 
 
2762
    return true;
 
2763
}
 
2764
 
 
2765
bool Parser::parseLabeledStatement(StatementAST *&node)
 
2766
{
 
2767
    switch(tokenStream->lookAhead()) {
 
2768
    case Token_identifier:
 
2769
    case Token_default:
 
2770
        if (tokenStream->lookAhead(1) == ':') {
 
2771
            advance();
 
2772
            advance();
 
2773
 
 
2774
            StatementAST *stmt = 0;
 
2775
            if (parseStatement(stmt)) {
 
2776
                node = stmt;
 
2777
                return true;
 
2778
            }
 
2779
        }
 
2780
        break;
 
2781
 
 
2782
    case Token_case:
 
2783
    {
 
2784
        advance();
 
2785
        AbstractExpressionAST *expr = 0;
 
2786
        if (!parseConstantExpression(expr)) {
 
2787
            reportError(i18n("expression expected"));
 
2788
        } else if (tokenStream->lookAhead() == Token_ellipsis) {
 
2789
            advance();
 
2790
 
 
2791
            AbstractExpressionAST *expr2 = 0;
 
2792
            if (!parseConstantExpression(expr2)) {
 
2793
                reportError(i18n("expression expected"));
 
2794
            }
 
2795
        }
 
2796
        ADVANCE(':', ":");
 
2797
 
 
2798
        StatementAST *stmt = 0;
 
2799
        if (parseStatement(stmt)) {
 
2800
            node = stmt;
 
2801
            return true;
 
2802
        }
 
2803
    }
 
2804
    break;
 
2805
 
 
2806
    }
 
2807
 
 
2808
    return false;
 
2809
}
 
2810
 
 
2811
bool Parser::parseBlockDeclaration(DeclarationAST *&node)
 
2812
{
 
2813
    switch(tokenStream->lookAhead()) {
 
2814
    case Token_typedef:
 
2815
        return parseTypedef(node);
 
2816
    case Token_using:
 
2817
        return parseUsing(node);
 
2818
    case Token_asm:
 
2819
        return parseAsmDefinition(node);
 
2820
    case Token_namespace:
 
2821
        return parseNamespaceAliasDefinition(node);
 
2822
    }
 
2823
 
 
2824
    int start = tokenStream->cursor();
 
2825
 
 
2826
    AST *storageSpec = 0;
 
2827
    parseStorageClassSpecifier(storageSpec);
 
2828
 
 
2829
    AST *cv = 0;
 
2830
    parseCvQualify(cv);
 
2831
 
 
2832
    TypeSpecifierAST *spec = 0;
 
2833
    if (!parseTypeSpecifierOrClassSpec(spec)) { // replace with simpleTypeSpecifier?!?!
 
2834
        tokenStream->rewind(start);
 
2835
        return false;
 
2836
    }
 
2837
    spec->setCvQualify(cv);
 
2838
 
 
2839
    AST *cv2 = 0;
 
2840
    parseCvQualify(cv2);
 
2841
    spec->setCv2Qualify(cv2);
 
2842
 
 
2843
    InitDeclaratorListAST *declarators = 0;
 
2844
    parseInitDeclaratorList(declarators);
 
2845
 
 
2846
    if (tokenStream->lookAhead() != ';') {
 
2847
        tokenStream->rewind(start);
 
2848
        return false;
 
2849
    }
 
2850
    advance();
 
2851
 
 
2852
    SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool);
 
2853
    ast->setTypeSpec(spec);
 
2854
    ast->setInitDeclaratorList(declarators);
 
2855
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2856
    node = ast;
 
2857
 
 
2858
    return true;
 
2859
}
 
2860
 
 
2861
bool Parser::parseNamespaceAliasDefinition(DeclarationAST *&/*node*/)
 
2862
{
 
2863
    if (tokenStream->lookAhead() != Token_namespace) {
 
2864
        return false;
 
2865
    }
 
2866
    advance();
 
2867
 
 
2868
    ADVANCE(Token_identifier,  "identifier");
 
2869
    ADVANCE('=', "=");
 
2870
 
 
2871
    NameAST *name = 0;
 
2872
    if (!parseName(name)) {
 
2873
        reportError(i18n("Namespace name expected"));
 
2874
    }
 
2875
 
 
2876
    ADVANCE(';', ";");
 
2877
 
 
2878
    return true;
 
2879
 
 
2880
}
 
2881
 
 
2882
bool Parser::parseDeclarationStatement(StatementAST *&node)
 
2883
{
 
2884
    int start = tokenStream->cursor();
 
2885
 
 
2886
    DeclarationAST *decl = 0;
 
2887
    if (!parseBlockDeclaration(decl))
 
2888
        return false;
 
2889
 
 
2890
    DeclarationStatementAST *ast = CreateNode<DeclarationStatementAST>(m_pool);
 
2891
    ast->setDeclaration(decl);
 
2892
    UPDATE_POS(ast, start, tokenStream->cursor());
 
2893
    node = ast;
 
2894
 
 
2895
    return true;
 
2896
}
 
2897
 
 
2898
bool Parser::parseDeclarationInternal(DeclarationAST *&node)
 
2899
{
 
2900
    int start = tokenStream->cursor();
 
2901
 
 
2902
    // that is for the case '__declspec(dllexport) int ...' or
 
2903
    // '__declspec(dllexport) inline int ...', etc.
 
2904
    AST *winDeclSpec = 0;
 
2905
    parseWinDeclSpec(winDeclSpec);
 
2906
 
 
2907
    AST *funSpec = 0;
 
2908
    bool hasFunSpec = parseFunctionSpecifier(funSpec);
 
2909
 
 
2910
    AST *storageSpec = 0;
 
2911
    bool hasStorageSpec = parseStorageClassSpecifier(storageSpec);
 
2912
 
 
2913
    if (hasStorageSpec && !hasFunSpec)
 
2914
        hasFunSpec = parseFunctionSpecifier(funSpec);
 
2915
 
 
2916
    // that is for the case 'friend __declspec(dllexport) ....'
 
2917
    AST *winDeclSpec2 = 0;
 
2918
    parseWinDeclSpec(winDeclSpec2);
 
2919
 
 
2920
    AST *cv = 0;
 
2921
    parseCvQualify(cv);
 
2922
 
 
2923
    int index = tokenStream->cursor();
 
2924
    NameAST *name = 0;
 
2925
    if (parseName(name) && tokenStream->lookAhead() == '(') {
 
2926
        // no type specifier, maybe a constructor or a cast operator??
 
2927
 
 
2928
        tokenStream->rewind(index);
 
2929
 
 
2930
        InitDeclaratorAST *declarator = 0;
 
2931
        if (parseInitDeclarator(declarator)) {
 
2932
            switch(tokenStream->lookAhead()) {
 
2933
            case ';':
 
2934
                {
 
2935
                    advance();
 
2936
 
 
2937
                    InitDeclaratorListAST *declarators = CreateNode<InitDeclaratorListAST>(m_pool);
 
2938
 
 
2939
                    // update declarators position
 
2940
                    if (declarator)
 
2941
                        declarators->setPosition(declarator->startToken(), declarator->endToken());
 
2942
                    declarators->addInitDeclarator(declarator);
 
2943
 
 
2944
                    SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool);
 
2945
                    ast->setInitDeclaratorList(declarators);
 
2946
                    node = ast;
 
2947
                    UPDATE_POS(node, start, tokenStream->cursor());
 
2948
                    return true;
 
2949
 
 
2950
                }
 
2951
                break;
 
2952
 
 
2953
            case ':':
 
2954
                {
 
2955
                    AST *ctorInit = 0;
 
2956
                    StatementListAST *funBody = 0;
 
2957
                    if (parseCtorInitializer(ctorInit) && parseFunctionBody(funBody)) {
 
2958
                        FunctionDefinitionAST *ast = CreateNode<FunctionDefinitionAST>(m_pool);
 
2959
                        ast->setStorageSpecifier(storageSpec);
 
2960
                        ast->setFunctionSpecifier(funSpec);
 
2961
                        ast->setInitDeclarator(declarator);
 
2962
                        ast->setFunctionBody(funBody);
 
2963
                        node = ast;
 
2964
                        UPDATE_POS(node, start, tokenStream->cursor());
 
2965
                        return true;
 
2966
                    }
 
2967
                }
 
2968
                break;
 
2969
 
 
2970
            case '{':
 
2971
                {
 
2972
                    StatementListAST *funBody = 0;
 
2973
                    if (parseFunctionBody(funBody)) {
 
2974
                        FunctionDefinitionAST *ast = CreateNode<FunctionDefinitionAST>(m_pool);
 
2975
                        ast->setStorageSpecifier(storageSpec);
 
2976
                        ast->setFunctionSpecifier(funSpec);
 
2977
                        ast->setInitDeclarator(declarator);
 
2978
                        ast->setFunctionBody(funBody);
 
2979
                        node = ast;
 
2980
                        UPDATE_POS(node, start, tokenStream->cursor());
 
2981
                        return true;
 
2982
                    }
 
2983
                }
 
2984
                break;
 
2985
 
 
2986
            case '(':
 
2987
            case '[':
 
2988
                // ops!! it seems a declarator
 
2989
                goto start_decl;
 
2990
                break;
 
2991
            }
 
2992
 
 
2993
        }
 
2994
    }
 
2995
 
 
2996
start_decl:
 
2997
    tokenStream->rewind(index);
 
2998
 
 
2999
    if (tokenStream->lookAhead() == Token_const && tokenStream->lookAhead(1) == Token_identifier && tokenStream->lookAhead(2) == '=') {
 
3000
        // constant definition
 
3001
        advance();
 
3002
        InitDeclaratorListAST *declarators = 0;
 
3003
        if (parseInitDeclaratorList(declarators)) {
 
3004
            ADVANCE(';', ";");
 
3005
            DeclarationAST *ast = CreateNode<DeclarationAST>(m_pool);
 
3006
            node = ast;
 
3007
            UPDATE_POS(node, start, tokenStream->cursor());
 
3008
            return true;
 
3009
        }
 
3010
        syntaxError();
 
3011
        return false;
 
3012
    }
 
3013
 
 
3014
    TypeSpecifierAST *spec = 0;
 
3015
    if (parseTypeSpecifier(spec)) {
 
3016
        if (!hasFunSpec)
 
3017
            parseFunctionSpecifier(funSpec);         // e.g. "void inline"
 
3018
        spec->setCvQualify(cv);
 
3019
 
 
3020
        InitDeclaratorListAST *declarators = 0;
 
3021
 
 
3022
        InitDeclaratorAST *decl = 0;
 
3023
        int startDeclarator = tokenStream->cursor();
 
3024
        bool maybeFunctionDefinition = false;
 
3025
 
 
3026
        if (tokenStream->lookAhead() != ';') {
 
3027
            if (parseInitDeclarator(decl) && tokenStream->lookAhead() == '{') {
 
3028
                // function definition
 
3029
                maybeFunctionDefinition = true;
 
3030
            } else {
 
3031
                tokenStream->rewind(startDeclarator);
 
3032
                if (!parseInitDeclaratorList(declarators)) {
 
3033
                    syntaxError();
 
3034
                    return false;
 
3035
                }
 
3036
            }
 
3037
        }
 
3038
 
 
3039
        switch(tokenStream->lookAhead()) {
 
3040
        case ';':
 
3041
            {
 
3042
                advance();
 
3043
                SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool);
 
3044
                ast->setStorageSpecifier(storageSpec);
 
3045
                ast->setFunctionSpecifier(funSpec);
 
3046
                ast->setTypeSpec(spec);
 
3047
                ast->setWinDeclSpec(winDeclSpec);
 
3048
                ast->setInitDeclaratorList(declarators);
 
3049
                node = ast;
 
3050
                UPDATE_POS(node, start, tokenStream->cursor());
 
3051
            }
 
3052
            return true;
 
3053
 
 
3054
        case '{':
 
3055
            {
 
3056
                if (!maybeFunctionDefinition) {
 
3057
                    syntaxError();
 
3058
                    return false;
 
3059
                }
 
3060
                StatementListAST *funBody = 0;
 
3061
                if (parseFunctionBody(funBody)) {
 
3062
                    FunctionDefinitionAST *ast = CreateNode<FunctionDefinitionAST>(m_pool);
 
3063
                    ast->setWinDeclSpec(winDeclSpec);
 
3064
                    ast->setStorageSpecifier(storageSpec);
 
3065
                    ast->setFunctionSpecifier(funSpec);
 
3066
                    ast->setTypeSpec(spec);
 
3067
                    ast->setInitDeclarator(decl);
 
3068
                    ast->setFunctionBody(funBody);
 
3069
                    node = ast;
 
3070
                    UPDATE_POS(node, start, tokenStream->cursor());
 
3071
                    return true;
 
3072
                }
 
3073
            }
 
3074
            break;
 
3075
 
 
3076
        }
 
3077
    }
 
3078
 
 
3079
    syntaxError();
 
3080
    return false;
 
3081
}
 
3082
 
 
3083
bool Parser::parseFunctionBody(StatementListAST *&node)
 
3084
{
 
3085
    int start = tokenStream->cursor();
 
3086
    if (tokenStream->lookAhead() != '{') {
 
3087
        return false;
 
3088
    }
 
3089
    advance();
 
3090
 
 
3091
    StatementListAST *ast = CreateNode<StatementListAST>(m_pool);
 
3092
 
 
3093
    while (tokenStream->lookAhead()) {
 
3094
        if (tokenStream->lookAhead() == '}')
 
3095
            break;
 
3096
 
 
3097
        StatementAST *stmt = 0;
 
3098
        int startStmt = tokenStream->cursor();
 
3099
        if (!parseStatement(stmt)) {
 
3100
            syntaxError();
 
3101
            if (startStmt == tokenStream->cursor())
 
3102
                advance();
 
3103
            skipUntilStatement();
 
3104
        } else
 
3105
            ast->addStatement(stmt);
 
3106
    }
 
3107
 
 
3108
    if (tokenStream->lookAhead() != '}') {
 
3109
        reportError(i18n("} expected"));
 
3110
    } else
 
3111
        advance();
 
3112
 
 
3113
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3114
    node = ast;
 
3115
 
 
3116
    return true;
 
3117
}
 
3118
 
 
3119
bool Parser::parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node)
 
3120
{
 
3121
    if (parseClassSpecifier(node))
 
3122
        return true;
 
3123
    else if (parseEnumSpecifier(node))
 
3124
        return true;
 
3125
    else if (parseTypeSpecifier(node))
 
3126
        return true;
 
3127
 
 
3128
    return false;
 
3129
}
 
3130
 
 
3131
bool Parser::parseTryBlockStatement(StatementAST *&node)
 
3132
{
 
3133
    if (tokenStream->lookAhead() != Token_try) {
 
3134
        return false;
 
3135
    }
 
3136
    advance();
 
3137
 
 
3138
    StatementAST *stmt = 0;
 
3139
    if (!parseCompoundStatement(stmt)) {
 
3140
        syntaxError();
 
3141
        return false;
 
3142
    }
 
3143
 
 
3144
    if (tokenStream->lookAhead() != Token_catch) {
 
3145
        reportError(i18n("catch expected"));
 
3146
        return false;
 
3147
    }
 
3148
 
 
3149
    while (tokenStream->lookAhead() == Token_catch) {
 
3150
        advance();
 
3151
        ADVANCE('(', "(");
 
3152
        ConditionAST *cond = 0;
 
3153
        if (tokenStream->lookAhead() == Token_ellipsis) {
 
3154
            advance();
 
3155
        } else if (!parseCondition(cond)) {
 
3156
            reportError(i18n("condition expected"));
 
3157
            return false;
 
3158
        }
 
3159
        ADVANCE(')', ")");
 
3160
 
 
3161
        StatementAST *body = 0;
 
3162
        if (!parseCompoundStatement(body)) {
 
3163
            syntaxError();
 
3164
            return false;
 
3165
        }
 
3166
    }
 
3167
 
 
3168
    node = stmt;
 
3169
    return true;
 
3170
}
 
3171
 
 
3172
bool Parser::parsePrimaryExpression(AbstractExpressionAST *&node)
 
3173
{
 
3174
    int start = tokenStream->cursor();
 
3175
 
 
3176
    AbstractExpressionAST *ast = CreateExpression<NodeType_PrimaryExpression>(m_pool);
 
3177
 
 
3178
    switch(tokenStream->lookAhead()) {
 
3179
        case Token_string_literal:
 
3180
        {
 
3181
            AST *lit = 0;
 
3182
            parseStringLiteral(lit);
 
3183
            if (lit)
 
3184
                lit->setParent(ast);
 
3185
        }
 
3186
        break;
 
3187
 
 
3188
        case Token_number_literal:
 
3189
        case Token_char_literal:
 
3190
        case Token_true:
 
3191
        case Token_false:
 
3192
        case Token_this:
 
3193
            {
 
3194
                AST_FROM_TOKEN(opNode, tokenStream->cursor());
 
3195
                opNode->setParent(ast);
 
3196
                advance();
 
3197
            }
 
3198
            break;
 
3199
 
 
3200
        case '(':
 
3201
            {
 
3202
                advance();
 
3203
 
 
3204
                if (tokenStream->lookAhead() == '{') {
 
3205
                    StatementAST *stmt = 0;
 
3206
                    if (!parseCompoundStatement(stmt))
 
3207
                        return false;
 
3208
                    if (stmt)
 
3209
                        stmt->setParent(ast);
 
3210
                } else {
 
3211
                    AbstractExpressionAST *expr = 0;
 
3212
                    if (!parseExpression(expr)) {
 
3213
                        return false;
 
3214
                    }
 
3215
                    if (expr)
 
3216
                        expr->setParent(ast);
 
3217
                }
 
3218
                CHECK(')', ")");
 
3219
            }
 
3220
            break;
 
3221
 
 
3222
        default:
 
3223
            {
 
3224
/*  ### reenable me
 
3225
                TypeSpecifierAST *typeSpec = 0;
 
3226
                if (parseSimpleTypeSpecifier(typeSpec) && tokenStream->lookAhead() == '(') {
 
3227
                    Q_ASSERT (0);
 
3228
                    advance();
 
3229
                    AbstractExpressionAST *expr = 0;
 
3230
                    parseCommaExpression(expr);
 
3231
                    CHECK(')', ")");
 
3232
                    break;
 
3233
 
 
3234
                    if (typeSpec)
 
3235
                        typeSpec->setParent(ast);
 
3236
 
 
3237
                    if (expr)
 
3238
                        expr->setParent(ast);
 
3239
                }
 
3240
 
 
3241
                tokenStream->rewind(start);
 
3242
*/
 
3243
 
 
3244
                NameAST *name = 0;
 
3245
                if (!parseName(name, false))
 
3246
                    return false;
 
3247
 
 
3248
                if (name)
 
3249
                    name->setParent(ast);
 
3250
 
 
3251
                break;
 
3252
            }
 
3253
    }
 
3254
 
 
3255
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3256
    node = ast;
 
3257
    return true;
 
3258
}
 
3259
 
 
3260
 
 
3261
/*
 
3262
   postfix-expression-internal:
 
3263
     [ expression ]
 
3264
     ( expression-list [opt] )
 
3265
     (.|->) template [opt] id-expression
 
3266
     (.|->) pseudo-destructor-name
 
3267
     ++
 
3268
     --
 
3269
*/
 
3270
bool Parser::parsePostfixExpressionInternal(AbstractExpressionAST *postfixExpr, AbstractExpressionAST *&node)
 
3271
{
 
3272
    Q_ASSERT (postfixExpr);
 
3273
 
 
3274
    int start = tokenStream->cursor();
 
3275
 
 
3276
    switch (tokenStream->lookAhead()) {
 
3277
        case '[':
 
3278
        {
 
3279
            advance();
 
3280
            AbstractExpressionAST *expr = 0;
 
3281
            parseExpression(expr);
 
3282
            CHECK(']', "]");
 
3283
 
 
3284
            SubscriptingAST *ast = CreateNode<SubscriptingAST>(m_pool);
 
3285
            ast->setExpression(postfixExpr);
 
3286
            ast->setSubscript(expr);
 
3287
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3288
            node = ast;
 
3289
        }
 
3290
        return true;
 
3291
 
 
3292
        case '(':
 
3293
        {
 
3294
            advance();
 
3295
            AbstractExpressionAST *expr = 0;
 
3296
            parseExpression(expr);
 
3297
            CHECK(')', ")");
 
3298
 
 
3299
            FunctionCallAST *ast = CreateNode<FunctionCallAST>(m_pool);
 
3300
            ast->setExpression(postfixExpr);
 
3301
            ast->setArguments(expr);
 
3302
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3303
            node = ast;
 
3304
        }
 
3305
        return true;
 
3306
 
 
3307
        case '.':
 
3308
        case Token_arrow:
 
3309
        {
 
3310
            AST_FROM_TOKEN(op, tokenStream->cursor());
 
3311
 
 
3312
            advance();
 
3313
            if (tokenStream->lookAhead() == Token_template)
 
3314
                advance();
 
3315
 
 
3316
            NameAST *name = 0;
 
3317
            if (!parseName(name))
 
3318
                return false;
 
3319
 
 
3320
            ClassMemberAccessAST *ast = CreateNode<ClassMemberAccessAST>(m_pool);
 
3321
            ast->setOp(op);
 
3322
            ast->setExpression(postfixExpr);
 
3323
            ast->setName(name);
 
3324
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3325
            node = ast;
 
3326
        }
 
3327
        return true;
 
3328
 
 
3329
        case Token_incr:
 
3330
        case Token_decr:
 
3331
        {
 
3332
            AST_FROM_TOKEN(op, tokenStream->cursor());
 
3333
            advance();
 
3334
 
 
3335
            IncrDecrAST *ast = CreateNode<IncrDecrAST>(m_pool);
 
3336
            ast->setExpression(postfixExpr);
 
3337
            ast->setOp(op);
 
3338
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3339
            node = ast;
 
3340
        }
 
3341
        return true;
 
3342
 
 
3343
        default:
 
3344
            return false;
 
3345
    }
 
3346
}
 
3347
 
 
3348
/*
 
3349
   postfix-expression:
 
3350
     simple-type-specifier ( expression-list [opt] )
 
3351
     primary-expression postfix-expression-internal*
 
3352
*/
 
3353
bool Parser::parsePostfixExpression(AbstractExpressionAST *&node)
 
3354
{
 
3355
    int start = tokenStream->cursor();
 
3356
 
 
3357
    switch (tokenStream->lookAhead()) {
 
3358
        case Token_dynamic_cast:
 
3359
        case Token_static_cast:
 
3360
        case Token_reinterpret_cast:
 
3361
        case Token_const_cast:
 
3362
        {
 
3363
            AST_FROM_TOKEN(castOp, tokenStream->cursor());
 
3364
 
 
3365
            advance();
 
3366
            CHECK('<', "<");
 
3367
            TypeIdAST *typeId = 0;
 
3368
            parseTypeId(typeId);
 
3369
            CHECK('>', ">");
 
3370
 
 
3371
            CHECK('(', ")");
 
3372
            AbstractExpressionAST *expr = 0;
 
3373
            parseCommaExpression(expr);
 
3374
            CHECK(')', ")");
 
3375
 
 
3376
            CppCastExpressionAST *tmp = CreateNode<CppCastExpressionAST>(m_pool);
 
3377
            tmp->setCastOp(castOp);
 
3378
            tmp->setTypeId(typeId);
 
3379
            tmp->setExpression(expr);
 
3380
 
 
3381
            AbstractExpressionAST *ast = tmp;
 
3382
            AbstractExpressionAST *e = 0;
 
3383
            while (parsePostfixExpressionInternal(ast, e)) {
 
3384
                ast = e;
 
3385
            }
 
3386
 
 
3387
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3388
            node = ast;
 
3389
        }
 
3390
        return true;
 
3391
 
 
3392
        case Token_typename:
 
3393
        {
 
3394
            advance();
 
3395
 
 
3396
            NameAST* name = 0;
 
3397
            if (!parseName(name))
 
3398
                return false;
 
3399
 
 
3400
            CHECK('(', "(");
 
3401
            AbstractExpressionAST *expr = 0;
 
3402
            parseCommaExpression(expr);
 
3403
            CHECK(')', ")");
 
3404
 
 
3405
            // ### AST
 
3406
        }
 
3407
        return true;
 
3408
 
 
3409
        case Token_typeid:
 
3410
        {
 
3411
            advance();
 
3412
 
 
3413
            CHECK('(', "(");
 
3414
            AbstractExpressionAST *expr = 0;
 
3415
            parseCommaExpression(expr);
 
3416
            CHECK(')', ")");
 
3417
 
 
3418
            // ### AST
 
3419
        }
 
3420
        return true;
 
3421
 
 
3422
        default:
 
3423
            break;
 
3424
    }
 
3425
 
 
3426
    TypeSpecifierAST *typeSpec = 0;
 
3427
    AbstractExpressionAST *expr = 0;
 
3428
 
 
3429
    if (parseSimpleTypeSpecifier(typeSpec/*, true*/) && tokenStream->lookAhead() == '(') {
 
3430
        advance(); // skip '('
 
3431
        parseCommaExpression(expr);
 
3432
        CHECK(')', ")");
 
3433
    } else {
 
3434
        tokenStream->rewind(start);
 
3435
 
 
3436
        if (!parsePrimaryExpression(expr))
 
3437
            return false;
 
3438
    }
 
3439
 
 
3440
    AbstractExpressionAST *ast = CreateExpression<NodeType_PostfixExpression>(m_pool);
 
3441
    if (typeSpec)
 
3442
        typeSpec->setParent(ast);
 
3443
 
 
3444
    if (expr)
 
3445
        expr->setParent(ast);
 
3446
 
 
3447
    AbstractExpressionAST *e = 0;
 
3448
    while (parsePostfixExpressionInternal(ast, e)) {
 
3449
        ast = e;
 
3450
    }
 
3451
 
 
3452
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3453
    node = ast;
 
3454
    return true;
 
3455
}
 
3456
 
 
3457
bool Parser::parseUnaryExpression(AbstractExpressionAST *&node)
 
3458
{
 
3459
    int start = tokenStream->cursor();
 
3460
 
 
3461
    switch(tokenStream->lookAhead()) {
 
3462
        case Token_incr:
 
3463
        case Token_decr:
 
3464
        case '*':
 
3465
        case '&':
 
3466
        case '+':
 
3467
        case '-':
 
3468
        case '!':
 
3469
        case '~':
 
3470
        {
 
3471
            AST_FROM_TOKEN(opNode, tokenStream->cursor());
 
3472
 
 
3473
            advance();
 
3474
            AbstractExpressionAST *expr = 0;
 
3475
            if (!parseCastExpression(expr))
 
3476
                return false;
 
3477
 
 
3478
            AbstractExpressionAST *ast = CreateExpression<NodeType_UnaryExpression>(m_pool);
 
3479
 
 
3480
            opNode->setParent(ast);
 
3481
            if (expr)
 
3482
                expr->setParent(ast);
 
3483
 
 
3484
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3485
            node = ast;
 
3486
            return true;
 
3487
        }
 
3488
 
 
3489
        case Token_sizeof:
 
3490
        {
 
3491
            AbstractExpressionAST *ast = CreateExpression<NodeType_UnaryExpression>(m_pool);
 
3492
 
 
3493
            AST_FROM_TOKEN(opNode, tokenStream->cursor());
 
3494
            opNode->setParent(ast);
 
3495
 
 
3496
            advance();
 
3497
            int index = tokenStream->cursor();
 
3498
            if (tokenStream->lookAhead() == '(') {
 
3499
                advance();
 
3500
                TypeIdAST *typeId = 0;
 
3501
                if (parseTypeId(typeId) && tokenStream->lookAhead() == ')') {
 
3502
                    if (typeId)
 
3503
                        typeId->setParent(ast);
 
3504
 
 
3505
                    advance();
 
3506
 
 
3507
                    UPDATE_POS(ast, start, tokenStream->cursor());
 
3508
                    node = ast;
 
3509
                    return true;
 
3510
                }
 
3511
                tokenStream->rewind(index);
 
3512
            }
 
3513
            AbstractExpressionAST *expr = 0;
 
3514
            if (!parseUnaryExpression(expr))
 
3515
                return false;
 
3516
 
 
3517
            UPDATE_POS(ast, start, tokenStream->cursor());
 
3518
            node = ast;
 
3519
            return true;
 
3520
        }
 
3521
 
 
3522
        case Token_new:
 
3523
            return parseNewExpression(node);
 
3524
 
 
3525
        case Token_delete:
 
3526
            return parseDeleteExpression(node);
 
3527
    }
 
3528
 
 
3529
    return parsePostfixExpression(node);
 
3530
}
 
3531
 
 
3532
bool Parser::parseNewExpression(AbstractExpressionAST *&node)
 
3533
{
 
3534
    int start = tokenStream->cursor();
 
3535
 
 
3536
    AbstractExpressionAST *ast = CreateExpression<NodeType_NewExpression>(m_pool);
 
3537
 
 
3538
    if (tokenStream->lookAhead() == Token_scope && tokenStream->lookAhead(1) == Token_new) {
 
3539
        AST_FROM_TOKEN(scopeNode, tokenStream->cursor());
 
3540
        scopeNode->setParent(ast);
 
3541
        advance();
 
3542
    }
 
3543
 
 
3544
    AST_FROM_TOKEN(newNode, tokenStream->cursor());
 
3545
    newNode->setParent(ast);
 
3546
 
 
3547
    CHECK(Token_new, "new");
 
3548
 
 
3549
    if (tokenStream->lookAhead() == '(') {
 
3550
        advance();
 
3551
        AbstractExpressionAST *expr = 0;
 
3552
        parseCommaExpression(expr);
 
3553
        if (expr)
 
3554
            expr->setParent(ast);
 
3555
        CHECK(')', ")");
 
3556
    }
 
3557
 
 
3558
    if (tokenStream->lookAhead() == '(') {
 
3559
        advance();
 
3560
        TypeIdAST *typeId = 0;
 
3561
        parseTypeId(typeId);
 
3562
        if (typeId)
 
3563
            typeId->setParent(ast);
 
3564
        CHECK(')', ")");
 
3565
    } else {
 
3566
        AbstractExpressionAST *typeId = 0;
 
3567
        parseNewTypeId(typeId);
 
3568
        if (typeId)
 
3569
            typeId->setParent(ast);
 
3570
    }
 
3571
 
 
3572
    AbstractExpressionAST *init = 0;
 
3573
    parseNewInitializer(init);
 
3574
    if (init)
 
3575
        init->setParent(ast);
 
3576
 
 
3577
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3578
    node = ast;
 
3579
    return true;
 
3580
}
 
3581
 
 
3582
bool Parser::parseNewTypeId(AbstractExpressionAST *&node)
 
3583
{
 
3584
    int start = tokenStream->cursor();
 
3585
 
 
3586
    TypeSpecifierAST *typeSpec = 0;
 
3587
    if (!parseTypeSpecifier(typeSpec))
 
3588
        return false;
 
3589
 
 
3590
    AbstractExpressionAST *ast = CreateExpression<NodeType_NewTypeId>(m_pool);
 
3591
 
 
3592
    if (typeSpec)
 
3593
        typeSpec->setParent(ast);
 
3594
 
 
3595
    AbstractExpressionAST *declarator = 0;
 
3596
    parseNewDeclarator(declarator);
 
3597
    if (declarator)
 
3598
        declarator->setParent(ast);
 
3599
 
 
3600
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3601
    node = ast;
 
3602
    return true;
 
3603
}
 
3604
 
 
3605
bool Parser::parseNewDeclarator(AbstractExpressionAST *&node)
 
3606
{
 
3607
    int start = tokenStream->cursor();
 
3608
 
 
3609
    AbstractExpressionAST *ast = CreateExpression<NodeType_NewInitializer>(m_pool);
 
3610
 
 
3611
    AST *ptrOp = 0;
 
3612
    if (parsePtrOperator(ptrOp)) {
 
3613
        if (ptrOp)
 
3614
            ptrOp->setParent(ast);
 
3615
 
 
3616
        AbstractExpressionAST *declarator = 0;
 
3617
        parseNewDeclarator(declarator);
 
3618
 
 
3619
        if (declarator)
 
3620
            declarator->setParent(ast);
 
3621
    }
 
3622
 
 
3623
    while (tokenStream->lookAhead() == '[') {
 
3624
        advance();
 
3625
        AbstractExpressionAST *expr = 0;
 
3626
        parseExpression(expr);
 
3627
        ADVANCE(']', "]");
 
3628
 
 
3629
        if (expr)
 
3630
            expr->setParent(ast);
 
3631
    }
 
3632
 
 
3633
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3634
    node = ast;
 
3635
    return true;
 
3636
}
 
3637
 
 
3638
bool Parser::parseNewInitializer(AbstractExpressionAST *&node)
 
3639
{
 
3640
    int start = tokenStream->cursor();
 
3641
 
 
3642
    if (tokenStream->lookAhead() != '(')
 
3643
        return false;
 
3644
 
 
3645
    AbstractExpressionAST *ast = CreateExpression<NodeType_NewInitializer>(m_pool);
 
3646
 
 
3647
    advance();
 
3648
    AbstractExpressionAST *expr = 0;
 
3649
    parseCommaExpression(expr);
 
3650
 
 
3651
    if (expr)
 
3652
        expr->setParent(ast);
 
3653
 
 
3654
    CHECK(')', ")");
 
3655
 
 
3656
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3657
    node = ast;
 
3658
    return true;
 
3659
}
 
3660
 
 
3661
bool Parser::parseDeleteExpression(AbstractExpressionAST *&node)
 
3662
{
 
3663
    int start = tokenStream->cursor();
 
3664
 
 
3665
    AbstractExpressionAST *ast = CreateExpression<NodeType_DeleteExpression>(m_pool);
 
3666
 
 
3667
    if (tokenStream->lookAhead() == Token_scope && tokenStream->lookAhead(1) == Token_delete) {
 
3668
        AST_FROM_TOKEN(scopeNode, tokenStream->cursor());
 
3669
        scopeNode->setParent(ast);
 
3670
        advance();
 
3671
    }
 
3672
 
 
3673
    AST_FROM_TOKEN(deleteNode, tokenStream->cursor());
 
3674
    deleteNode->setParent(ast);
 
3675
 
 
3676
    CHECK(Token_delete, "delete");
 
3677
 
 
3678
    if (tokenStream->lookAhead() == '[') {
 
3679
        int beg = tokenStream->cursor();
 
3680
        advance();
 
3681
        CHECK(']', "]");
 
3682
 
 
3683
        AST *n = CreateNode<AST>(m_pool);
 
3684
        UPDATE_POS(n, beg, tokenStream->cursor());
 
3685
        n->setParent(ast);
 
3686
    }
 
3687
 
 
3688
    AbstractExpressionAST *expr = 0;
 
3689
    if (!parseCastExpression(expr))
 
3690
        return false;
 
3691
 
 
3692
    if (expr)
 
3693
        expr->setParent(ast);
 
3694
 
 
3695
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3696
    node = ast;
 
3697
    return true;
 
3698
}
 
3699
 
 
3700
bool Parser::parseCastExpression(AbstractExpressionAST *&node)
 
3701
{
 
3702
    int start = tokenStream->cursor();
 
3703
 
 
3704
    if (tokenStream->lookAhead() == '(') {
 
3705
        AbstractExpressionAST *ast = CreateExpression<NodeType_CastExpression>(m_pool);
 
3706
 
 
3707
        advance();
 
3708
        TypeIdAST *typeId = 0;
 
3709
        if (parseTypeId(typeId)) {
 
3710
 
 
3711
            if (typeId)
 
3712
                typeId->setParent(ast);
 
3713
 
 
3714
            if (tokenStream->lookAhead() == ')') {
 
3715
                advance();
 
3716
 
 
3717
                AbstractExpressionAST *expr = 0;
 
3718
                if (parseCastExpression(expr)) {
 
3719
                    if (expr)
 
3720
                        expr->setParent(ast);
 
3721
 
 
3722
                    UPDATE_POS(ast, start, tokenStream->cursor());
 
3723
                    node = ast;
 
3724
                    return true;
 
3725
                }
 
3726
            }
 
3727
        }
 
3728
    }
 
3729
 
 
3730
    tokenStream->rewind(start);
 
3731
    return parseUnaryExpression(node);
 
3732
}
 
3733
 
 
3734
bool Parser::parsePmExpression(AbstractExpressionAST *&node)
 
3735
{
 
3736
    int start = tokenStream->cursor();
 
3737
 
 
3738
    AbstractExpressionAST *ast = 0;
 
3739
    if (!parseCastExpression(ast) || !ast) // ### fixme
 
3740
        return false;
 
3741
 
 
3742
    while (tokenStream->lookAhead() == Token_ptrmem) {
 
3743
        int startOp = tokenStream->cursor();
 
3744
        AST_FROM_TOKEN(op, startOp);
 
3745
        advance();
 
3746
 
 
3747
        AbstractExpressionAST *rightExpr = 0;
 
3748
        if (!parseCastExpression(rightExpr))
 
3749
            return false;
 
3750
 
 
3751
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3752
        tmp->setOp(op);
 
3753
        tmp->setLeftExpression(ast);
 
3754
        tmp->setRightExpression(rightExpr);
 
3755
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3756
        ast = tmp;
 
3757
    }
 
3758
 
 
3759
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3760
    node = ast;
 
3761
    return true;
 
3762
}
 
3763
 
 
3764
bool Parser::parseMultiplicativeExpression(AbstractExpressionAST *&node)
 
3765
{
 
3766
    int start = tokenStream->cursor();
 
3767
 
 
3768
    AbstractExpressionAST *ast = 0;
 
3769
    if (!parsePmExpression(ast))
 
3770
        return false;
 
3771
 
 
3772
    while (tokenStream->lookAhead() == '*' || tokenStream->lookAhead() == '/' || tokenStream->lookAhead() == '%') {
 
3773
        int startOp = tokenStream->cursor();
 
3774
        AST_FROM_TOKEN(op, startOp);
 
3775
        advance();
 
3776
 
 
3777
        AbstractExpressionAST *rightExpr = 0;
 
3778
        if (!parsePmExpression(rightExpr))
 
3779
            return false;
 
3780
 
 
3781
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3782
        tmp->setOp(op);
 
3783
        tmp->setLeftExpression(ast);
 
3784
        tmp->setRightExpression(rightExpr);
 
3785
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3786
        ast = tmp;
 
3787
    }
 
3788
 
 
3789
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3790
    node = ast;
 
3791
    return true;
 
3792
}
 
3793
 
 
3794
 
 
3795
bool Parser::parseAdditiveExpression(AbstractExpressionAST *&node)
 
3796
{
 
3797
    int start = tokenStream->cursor();
 
3798
 
 
3799
    AbstractExpressionAST *ast = 0;
 
3800
    if (!parseMultiplicativeExpression(ast))
 
3801
        return false;
 
3802
 
 
3803
    while (tokenStream->lookAhead() == '+' || tokenStream->lookAhead() == '-') {
 
3804
        int startOp = tokenStream->cursor();
 
3805
        AST_FROM_TOKEN(op, startOp);
 
3806
        advance();
 
3807
 
 
3808
        AbstractExpressionAST *rightExpr = 0;
 
3809
        if (!parseMultiplicativeExpression(rightExpr))
 
3810
            return false;
 
3811
 
 
3812
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3813
        tmp->setOp(op);
 
3814
        tmp->setLeftExpression(ast);
 
3815
        tmp->setRightExpression(rightExpr);
 
3816
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3817
        ast = tmp;
 
3818
    }
 
3819
 
 
3820
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3821
    node = ast;
 
3822
    return true;
 
3823
}
 
3824
 
 
3825
bool Parser::parseShiftExpression(AbstractExpressionAST *&node)
 
3826
{
 
3827
    int start = tokenStream->cursor();
 
3828
 
 
3829
    AbstractExpressionAST *ast = 0;
 
3830
    if (!parseAdditiveExpression(ast))
 
3831
        return false;
 
3832
 
 
3833
    while (tokenStream->lookAhead() == Token_shift) {
 
3834
        int startOp = tokenStream->cursor();
 
3835
        AST_FROM_TOKEN(op, startOp);
 
3836
        advance();
 
3837
 
 
3838
        AbstractExpressionAST *rightExpr = 0;
 
3839
        if (!parseAdditiveExpression(rightExpr))
 
3840
            return false;
 
3841
 
 
3842
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3843
        tmp->setOp(op);
 
3844
        tmp->setLeftExpression(ast);
 
3845
        tmp->setRightExpression(rightExpr);
 
3846
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3847
        ast = tmp;
 
3848
    }
 
3849
 
 
3850
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3851
    node = ast;
 
3852
    return true;
 
3853
}
 
3854
 
 
3855
bool Parser::parseRelationalExpression(AbstractExpressionAST *&node, bool templArgs)
 
3856
{
 
3857
    int start = tokenStream->cursor();
 
3858
 
 
3859
    AbstractExpressionAST *ast = 0;
 
3860
    if (!parseShiftExpression(ast))
 
3861
        return false;
 
3862
 
 
3863
    while (tokenStream->lookAhead() == '<' || (tokenStream->lookAhead() == '>' && !templArgs) ||
 
3864
           tokenStream->lookAhead() == Token_leq || tokenStream->lookAhead() == Token_geq) {
 
3865
        int startOp = tokenStream->cursor();
 
3866
        AST_FROM_TOKEN(op, startOp);
 
3867
        advance();
 
3868
 
 
3869
        AbstractExpressionAST *rightExpr = 0;
 
3870
        if (!parseShiftExpression(rightExpr))
 
3871
            return false;
 
3872
 
 
3873
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3874
        tmp->setOp(op);
 
3875
        tmp->setLeftExpression(ast);
 
3876
        tmp->setRightExpression(rightExpr);
 
3877
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3878
        ast = tmp;
 
3879
    }
 
3880
 
 
3881
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3882
    node = ast;
 
3883
    return true;
 
3884
}
 
3885
 
 
3886
bool Parser::parseEqualityExpression(AbstractExpressionAST *&node, bool templArgs)
 
3887
{
 
3888
    int start = tokenStream->cursor();
 
3889
 
 
3890
    AbstractExpressionAST *ast = 0;
 
3891
    if (!parseRelationalExpression(ast, templArgs))
 
3892
        return false;
 
3893
 
 
3894
    while (tokenStream->lookAhead() == Token_eq || tokenStream->lookAhead() == Token_not_eq) {
 
3895
        int startOp = tokenStream->cursor();
 
3896
        AST_FROM_TOKEN(op, startOp);
 
3897
        advance();
 
3898
 
 
3899
        AbstractExpressionAST *rightExpr = 0;
 
3900
        if (!parseRelationalExpression(rightExpr, templArgs))
 
3901
            return false;
 
3902
 
 
3903
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3904
        tmp->setOp(op);
 
3905
        tmp->setLeftExpression(ast);
 
3906
        tmp->setRightExpression(rightExpr);
 
3907
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3908
        ast = tmp;
 
3909
    }
 
3910
 
 
3911
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3912
    node = ast;
 
3913
    return true;
 
3914
}
 
3915
 
 
3916
bool Parser::parseAndExpression(AbstractExpressionAST *&node, bool templArgs)
 
3917
{
 
3918
    int start = tokenStream->cursor();
 
3919
 
 
3920
    AbstractExpressionAST *ast = 0;
 
3921
    if (!parseEqualityExpression(ast, templArgs))
 
3922
        return false;
 
3923
 
 
3924
    while (tokenStream->lookAhead() == '&') {
 
3925
        int startOp = tokenStream->cursor();
 
3926
        AST_FROM_TOKEN(op, startOp);
 
3927
        advance();
 
3928
 
 
3929
        AbstractExpressionAST *rightExpr = 0;
 
3930
        if (!parseEqualityExpression(rightExpr, templArgs))
 
3931
            return false;
 
3932
 
 
3933
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3934
        tmp->setOp(op);
 
3935
        tmp->setLeftExpression(ast);
 
3936
        tmp->setRightExpression(rightExpr);
 
3937
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3938
        ast = tmp;
 
3939
    }
 
3940
 
 
3941
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3942
    node = ast;
 
3943
    return true;
 
3944
}
 
3945
 
 
3946
bool Parser::parseExclusiveOrExpression(AbstractExpressionAST *&node, bool templArgs)
 
3947
{
 
3948
    int start = tokenStream->cursor();
 
3949
 
 
3950
    AbstractExpressionAST *ast = 0;
 
3951
    if (!parseAndExpression(ast, templArgs))
 
3952
        return false;
 
3953
 
 
3954
    while (tokenStream->lookAhead() == '^') {
 
3955
        int startOp = tokenStream->cursor();
 
3956
        AST_FROM_TOKEN(op, startOp);
 
3957
        advance();
 
3958
 
 
3959
        AbstractExpressionAST *rightExpr = 0;
 
3960
        if (!parseAndExpression(rightExpr, templArgs))
 
3961
            return false;
 
3962
 
 
3963
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3964
        tmp->setOp(op);
 
3965
        tmp->setLeftExpression(ast);
 
3966
        tmp->setRightExpression(rightExpr);
 
3967
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3968
        ast = tmp;
 
3969
    }
 
3970
 
 
3971
    UPDATE_POS(ast, start, tokenStream->cursor());
 
3972
    node = ast;
 
3973
    return true;
 
3974
}
 
3975
 
 
3976
bool Parser::parseInclusiveOrExpression(AbstractExpressionAST *&node, bool templArgs)
 
3977
{
 
3978
    int start = tokenStream->cursor();
 
3979
 
 
3980
    AbstractExpressionAST *ast = 0;
 
3981
    if (!parseExclusiveOrExpression(ast, templArgs))
 
3982
        return false;
 
3983
 
 
3984
    while (tokenStream->lookAhead() == '|') {
 
3985
        int startOp = tokenStream->cursor();
 
3986
        AST_FROM_TOKEN(op, startOp);
 
3987
        advance();
 
3988
 
 
3989
        AbstractExpressionAST *rightExpr = 0;
 
3990
        if (!parseExclusiveOrExpression(rightExpr, templArgs))
 
3991
            return false;
 
3992
 
 
3993
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
3994
        tmp->setOp(op);
 
3995
        tmp->setLeftExpression(ast);
 
3996
        tmp->setRightExpression(rightExpr);
 
3997
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
3998
        ast = tmp;
 
3999
    }
 
4000
 
 
4001
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4002
    node = ast;
 
4003
    return true;
 
4004
}
 
4005
 
 
4006
bool Parser::parseLogicalAndExpression(AbstractExpressionAST *&node, bool templArgs)
 
4007
{
 
4008
    int start = tokenStream->cursor();
 
4009
 
 
4010
    AbstractExpressionAST *ast = 0;
 
4011
    if (!parseInclusiveOrExpression(ast, templArgs))
 
4012
        return false;
 
4013
 
 
4014
    while (tokenStream->lookAhead() == Token_and) {
 
4015
        int startOp = tokenStream->cursor();
 
4016
        AST_FROM_TOKEN(op, startOp);
 
4017
        advance();
 
4018
 
 
4019
        AbstractExpressionAST *rightExpr = 0;
 
4020
        if (!parseInclusiveOrExpression(rightExpr, templArgs))
 
4021
            return false;
 
4022
 
 
4023
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
4024
        tmp->setOp(op);
 
4025
        tmp->setLeftExpression(ast);
 
4026
        tmp->setRightExpression(rightExpr);
 
4027
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
4028
        ast = tmp;
 
4029
    }
 
4030
 
 
4031
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4032
    node = ast;
 
4033
    return true;
 
4034
}
 
4035
 
 
4036
bool Parser::parseLogicalOrExpression(AbstractExpressionAST *&node, bool templArgs)
 
4037
{
 
4038
    int start = tokenStream->cursor();
 
4039
 
 
4040
    AbstractExpressionAST *ast = 0;
 
4041
    if (!parseLogicalAndExpression(ast, templArgs))
 
4042
        return false;
 
4043
 
 
4044
    while (tokenStream->lookAhead() == Token_or) {
 
4045
        int startOp = tokenStream->cursor();
 
4046
        AST_FROM_TOKEN(op, startOp);
 
4047
        advance();
 
4048
 
 
4049
        AbstractExpressionAST *rightExpr = 0;
 
4050
        if (!parseLogicalAndExpression(rightExpr, templArgs))
 
4051
            return false;
 
4052
 
 
4053
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
4054
        tmp->setOp(op);
 
4055
        tmp->setLeftExpression(ast);
 
4056
        tmp->setRightExpression(rightExpr);
 
4057
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
4058
        ast = tmp;
 
4059
    }
 
4060
 
 
4061
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4062
    node = ast;
 
4063
    return true;
 
4064
}
 
4065
 
 
4066
bool Parser::parseConditionalExpression(AbstractExpressionAST *&node)
 
4067
{
 
4068
    int start = tokenStream->cursor();
 
4069
 
 
4070
    AbstractExpressionAST *ast = 0;
 
4071
    if (!parseLogicalOrExpression(ast))
 
4072
        return false;
 
4073
 
 
4074
    if (tokenStream->lookAhead() == '?') {
 
4075
        advance();
 
4076
 
 
4077
        AbstractExpressionAST *leftExpr = 0;
 
4078
        if (!parseExpression(leftExpr))
 
4079
            return false;
 
4080
 
 
4081
        CHECK(':', ":");
 
4082
 
 
4083
        AbstractExpressionAST *rightExpr = 0;
 
4084
        if (!parseAssignmentExpression(rightExpr))
 
4085
            return false;
 
4086
 
 
4087
        ConditionalExpressionAST *tmp = CreateNode<ConditionalExpressionAST>(m_pool);
 
4088
        tmp->setCondition(ast);
 
4089
        tmp->setLeftExpression(leftExpr);
 
4090
        tmp->setRightExpression(rightExpr);
 
4091
        ast = tmp;
 
4092
    }
 
4093
 
 
4094
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4095
    node = ast;
 
4096
    return true;
 
4097
}
 
4098
 
 
4099
bool Parser::parseAssignmentExpression(AbstractExpressionAST *&node)
 
4100
{
 
4101
    int start = tokenStream->cursor();
 
4102
 
 
4103
    AbstractExpressionAST *ast = 0;
 
4104
    if (tokenStream->lookAhead() == Token_throw && !parseThrowExpression(ast))
 
4105
        return false;
 
4106
    else if (!parseConditionalExpression(ast))
 
4107
        return false;
 
4108
 
 
4109
    while (tokenStream->lookAhead() == Token_assign || tokenStream->lookAhead() == '=') {
 
4110
        int startOp = tokenStream->cursor();
 
4111
        AST_FROM_TOKEN(op, startOp);
 
4112
        advance();
 
4113
 
 
4114
        AbstractExpressionAST *rightExpr = 0;
 
4115
        if (!parseConditionalExpression(rightExpr))
 
4116
            return false;
 
4117
 
 
4118
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
4119
        tmp->setOp(op);
 
4120
        tmp->setLeftExpression(ast);
 
4121
        tmp->setRightExpression(rightExpr);
 
4122
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
4123
        ast = tmp;
 
4124
    }
 
4125
 
 
4126
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4127
    node = ast;
 
4128
    return true;
 
4129
}
 
4130
 
 
4131
bool Parser::parseConstantExpression(AbstractExpressionAST *&node)
 
4132
{
 
4133
    return parseConditionalExpression(node);
 
4134
}
 
4135
 
 
4136
bool Parser::parseExpression(AbstractExpressionAST *&node)
 
4137
{
 
4138
    return parseCommaExpression(node);
 
4139
}
 
4140
 
 
4141
bool Parser::parseCommaExpression(AbstractExpressionAST *&node)
 
4142
{
 
4143
    int start = tokenStream->cursor();
 
4144
 
 
4145
    AbstractExpressionAST *ast = 0;
 
4146
    if (!parseAssignmentExpression(ast))
 
4147
        return false;
 
4148
 
 
4149
    while (tokenStream->lookAhead() == ',') {
 
4150
        int startOp = tokenStream->cursor();
 
4151
        AST_FROM_TOKEN(op, startOp);
 
4152
        advance();
 
4153
 
 
4154
        AbstractExpressionAST *rightExpr = 0;
 
4155
        if (!parseAssignmentExpression(rightExpr))
 
4156
            return false;
 
4157
 
 
4158
        BinaryExpressionAST *tmp = CreateNode<BinaryExpressionAST>(m_pool);
 
4159
        tmp->setOp(op);
 
4160
        tmp->setLeftExpression(ast);
 
4161
        tmp->setRightExpression(rightExpr);
 
4162
        UPDATE_POS(tmp, startOp, tokenStream->cursor());
 
4163
        ast = tmp;
 
4164
    }
 
4165
 
 
4166
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4167
    node = ast;
 
4168
    return true;
 
4169
}
 
4170
 
 
4171
bool Parser::parseThrowExpression(AbstractExpressionAST *&node)
 
4172
{
 
4173
    if (tokenStream->lookAhead() != Token_throw)
 
4174
        return false;
 
4175
 
 
4176
    int start = tokenStream->cursor();
 
4177
 
 
4178
    AST_FROM_TOKEN(throwNode, tokenStream->cursor());
 
4179
    CHECK(Token_throw, "throw");
 
4180
    AbstractExpressionAST *expr = 0;
 
4181
    if (!parseAssignmentExpression(expr))
 
4182
        return false;
 
4183
 
 
4184
    AbstractExpressionAST *ast = CreateExpression<NodeType_ThrowExpression>(m_pool);
 
4185
    throwNode->setParent(ast);
 
4186
    if (expr)
 
4187
        expr->setParent(ast);
 
4188
 
 
4189
    UPDATE_POS(ast, start, tokenStream->cursor());
 
4190
    node = ast;
 
4191
 
 
4192
    return true;
 
4193
}
 
4194
 
 
4195
 
 
4196
// ### Objective C++
 
4197
bool Parser::parseIvarDeclList(AST *& node)
 
4198
{
 
4199
    Q_UNUSED(node);
 
4200
    return false;
 
4201
}
 
4202
 
 
4203
bool Parser::parseIvarDecls(AST *& node)
 
4204
{
 
4205
    Q_UNUSED(node);
 
4206
    return false;
 
4207
}
 
4208
 
 
4209
bool Parser::parseIvarDecl(AST *& node)
 
4210
{
 
4211
    Q_UNUSED(node);
 
4212
    return false;
 
4213
}
 
4214
 
 
4215
bool Parser::parseIvars(AST *& node)
 
4216
{
 
4217
    Q_UNUSED(node);
 
4218
    return false;
 
4219
}
 
4220
 
 
4221
bool Parser::parseIvarDeclarator(AST *& node)
 
4222
{
 
4223
    Q_UNUSED(node);
 
4224
    return false;
 
4225
}
 
4226
 
 
4227
bool Parser::parseMethodDecl(AST *& node)
 
4228
{
 
4229
    Q_UNUSED(node);
 
4230
    return false;
 
4231
}
 
4232
 
 
4233
bool Parser::parseUnarySelector(AST *& node)
 
4234
{
 
4235
    Q_UNUSED(node);
 
4236
    return false;
 
4237
}
 
4238
 
 
4239
bool Parser::parseKeywordSelector(AST *& node)
 
4240
{
 
4241
    Q_UNUSED(node);
 
4242
    return false;
 
4243
}
 
4244
 
 
4245
bool Parser::parseSelector(AST *& node)
 
4246
{
 
4247
    Q_UNUSED(node);
 
4248
    return false;
 
4249
}
 
4250
 
 
4251
bool Parser::parseKeywordDecl(AST *& node)
 
4252
{
 
4253
    Q_UNUSED(node);
 
4254
    return false;
 
4255
}
 
4256
 
 
4257
bool Parser::parseReceiver(AST *& node)
 
4258
{
 
4259
    Q_UNUSED(node);
 
4260
    return false;
 
4261
}
 
4262
 
 
4263
bool Parser::parseObjcMessageExpr(AST *& node)
 
4264
{
 
4265
    Q_UNUSED(node);
 
4266
    return false;
 
4267
}
 
4268
 
 
4269
bool Parser::parseMessageArgs(AST *& node)
 
4270
{
 
4271
    Q_UNUSED(node);
 
4272
    return false;
 
4273
}
 
4274
 
 
4275
bool Parser::parseKeywordExpr(AST *& node)
 
4276
{
 
4277
    Q_UNUSED(node);
 
4278
    return false;
 
4279
}
 
4280
 
 
4281
bool Parser::parseKeywordArgList(AST *& node)
 
4282
{
 
4283
    Q_UNUSED(node);
 
4284
    return false;
 
4285
}
 
4286
 
 
4287
bool Parser::parseKeywordArg(AST *& node)
 
4288
{
 
4289
    Q_UNUSED(node);
 
4290
    return false;
 
4291
}
 
4292
 
 
4293
bool Parser::parseReservedWord(AST *& node)
 
4294
{
 
4295
    Q_UNUSED(node);
 
4296
    return false;
 
4297
}
 
4298
 
 
4299
bool Parser::parseMyParms(AST *& node)
 
4300
{
 
4301
    Q_UNUSED(node);
 
4302
    return false;
 
4303
}
 
4304
 
 
4305
bool Parser::parseMyParm(AST *& node)
 
4306
{
 
4307
    Q_UNUSED(node);
 
4308
    return false;
 
4309
}
 
4310
 
 
4311
bool Parser::parseOptParmList(AST *& node)
 
4312
{
 
4313
    Q_UNUSED(node);
 
4314
    return false;
 
4315
}
 
4316
 
 
4317
bool Parser::parseObjcSelectorExpr(AST *& node)
 
4318
{
 
4319
    Q_UNUSED(node);
 
4320
    return false;
 
4321
}
 
4322
 
 
4323
bool Parser::parseSelectorArg(AST *& node)
 
4324
{
 
4325
    Q_UNUSED(node);
 
4326
    return false;
 
4327
}
 
4328
 
 
4329
bool Parser::parseKeywordNameList(AST *& node)
 
4330
{
 
4331
    Q_UNUSED(node);
 
4332
    return false;
 
4333
}
 
4334
 
 
4335
bool Parser::parseKeywordName(AST *& node)
 
4336
{
 
4337
    Q_UNUSED(node);
 
4338
    return false;
 
4339
}
 
4340
 
 
4341
bool Parser::parseObjcEncodeExpr(AST *& node)
 
4342
{
 
4343
    Q_UNUSED(node);
 
4344
    return false;
 
4345
}
 
4346
 
 
4347
bool Parser::parseObjcString(AST *& node)
 
4348
{
 
4349
    Q_UNUSED(node);
 
4350
    return false;
 
4351
}
 
4352
 
 
4353
bool Parser::parseProtocolRefs(AST *& node)
 
4354
{
 
4355
    Q_UNUSED(node);
 
4356
    return false;
 
4357
}
 
4358
 
 
4359
bool Parser::parseIdentifierList(AST *& node)
 
4360
{
 
4361
    int start = tokenStream->cursor();
 
4362
 
 
4363
    if (tokenStream->lookAhead() != Token_identifier)
 
4364
        return false;
 
4365
 
 
4366
    AST *ast = CreateNode<AST>(m_pool);
 
4367
 
 
4368
    AST_FROM_TOKEN(tk, tokenStream->cursor());
 
4369
    tk->setParent(ast);
 
4370
    advance();
 
4371
 
 
4372
    while (tokenStream->lookAhead() == ',') {
 
4373
        advance();
 
4374
        if (tokenStream->lookAhead() == Token_identifier) {
 
4375
            AST_FROM_TOKEN(tk, tokenStream->cursor());
 
4376
            tk->setParent(ast);
 
4377
            advance();
 
4378
        }
 
4379
        ADVANCE(Token_identifier, "identifier");
 
4380
    }
 
4381
 
 
4382
    node = ast;
 
4383
    UPDATE_POS(node, start, tokenStream->cursor());
 
4384
    return true;
 
4385
}
 
4386
 
 
4387
bool Parser::parseIdentifierColon(AST *& node)
 
4388
{
 
4389
    Q_UNUSED(node);
 
4390
 
 
4391
    if (tokenStream->lookAhead() == Token_identifier && tokenStream->lookAhead(1) == ':') {
 
4392
        advance();
 
4393
        advance();
 
4394
        return true;
 
4395
    } // ### else if PTYPENAME -> return true ;
 
4396
 
 
4397
    return false;
 
4398
}
 
4399
 
 
4400
bool Parser::parseObjcProtocolExpr(AST *& node)
 
4401
{
 
4402
    Q_UNUSED(node);
 
4403
    return false;
 
4404
}
 
4405
 
 
4406
bool Parser::parseObjcOpenBracketExpr(AST *& node)
 
4407
{
 
4408
    Q_UNUSED(node);
 
4409
    return false;
 
4410
}
 
4411
 
 
4412
bool Parser::parseObjcCloseBracket(AST *& node)
 
4413
{
 
4414
    Q_UNUSED(node);
 
4415
    return false;
 
4416
}
 
4417
 
 
4418
bool Parser::parseObjcDef(DeclarationAST *& node)
 
4419
{
 
4420
    Q_UNUSED(node);
 
4421
    return false;
 
4422
}
 
4423
 
 
4424
bool Parser::parseObjcClassDef(DeclarationAST *& node)
 
4425
{
 
4426
    Q_UNUSED(node);
 
4427
    return false;
 
4428
}
 
4429
 
 
4430
bool Parser::parseObjcClassDecl(DeclarationAST *& node)
 
4431
{
 
4432
    Q_UNUSED(node);
 
4433
 
 
4434
    ADVANCE(OBJC_CLASS, "@class");
 
4435
 
 
4436
    AST *idList = 0;
 
4437
    parseIdentifierList(idList);
 
4438
    ADVANCE(';', ";");
 
4439
 
 
4440
    return true;
 
4441
}
 
4442
 
 
4443
bool Parser::parseObjcProtocolDecl(DeclarationAST *& node)
 
4444
{
 
4445
    Q_UNUSED(node);
 
4446
 
 
4447
    ADVANCE(OBJC_PROTOCOL, "@protocol");
 
4448
 
 
4449
    AST *idList = 0;
 
4450
    parseIdentifierList(idList);
 
4451
    ADVANCE(';', ";");
 
4452
 
 
4453
    return true;
 
4454
}
 
4455
 
 
4456
bool Parser::parseObjcAliasDecl(DeclarationAST *& node)
 
4457
{
 
4458
    Q_UNUSED(node);
 
4459
 
 
4460
    ADVANCE(OBJC_ALIAS, "@alias");
 
4461
 
 
4462
    AST *idList = 0;
 
4463
    parseIdentifierList(idList);
 
4464
    ADVANCE(';', ";");
 
4465
 
 
4466
    return true;
 
4467
}
 
4468
 
 
4469
bool Parser::parseObjcProtocolDef(DeclarationAST *& node)
 
4470
{
 
4471
    Q_UNUSED(node);
 
4472
    return false;
 
4473
}
 
4474
 
 
4475
bool Parser::parseObjcMethodDef(DeclarationAST *& node)
 
4476
{
 
4477
    Q_UNUSED(node);
 
4478
    return false;
 
4479
}
 
4480
 
 
4481
bool Parser::parseWinDeclSpec(AST *& node)
 
4482
{
 
4483
    if (tokenStream->lookAhead() == Token_identifier
 
4484
            && tokenStream->lookAhead(1) == '('
 
4485
            && tokenStream->currentTokenText() == "__declspec") {
 
4486
        int start = tokenStream->cursor();
 
4487
        advance();
 
4488
        advance(); // skip '('
 
4489
 
 
4490
        parseIdentifierList(node);
 
4491
        ADVANCE(')', ")");
 
4492
 
 
4493
        UPDATE_POS(node, start, tokenStream->cursor());
 
4494
        return true;
 
4495
    }
 
4496
 
 
4497
    return false;
 
4498
}
 
4499
 
 
4500
void Parser::advance()
 
4501
{
 
4502
    for (;;) {
 
4503
        tokenStream->nextToken();
 
4504
        if (!tokenStream->isHidden(tokenStream->cursor()))
 
4505
            break;
 
4506
    }
 
4507
}
 
4508