cpptoxml/parser/parser.cpp

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