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

     2 **

     3 ** Copyright (C) 2001-2004 Roberto Raggi

     4 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     5 ** All rights reserved.

     6 ** Contact: Nokia Corporation (qt-info@nokia.com)

     7 **

     8 ** This file is part of the qt3to4 porting application of the Qt Toolkit.

     9 **

    10 ** $QT_BEGIN_LICENSE:LGPL$

    11 ** No Commercial Usage

    12 ** This file contains pre-release code and may not be distributed.

    13 ** You may use this file in accordance with the terms and conditions

    14 ** contained in the Technology Preview License Agreement accompanying

    15 ** this package.

    16 **

    17 ** GNU Lesser General Public License Usage

    18 ** Alternatively, this file may be used under the terms of the GNU Lesser

    19 ** General Public License version 2.1 as published by the Free Software

    20 ** Foundation and appearing in the file LICENSE.LGPL included in the

    21 ** packaging of this file.  Please review the following information to

    22 ** ensure the GNU Lesser General Public License version 2.1 requirements

    23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    24 **

    25 ** In addition, as a special exception, Nokia gives you certain additional

    26 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    28 **

    29 ** If you have questions regarding the use of this file, please contact

    30 ** Nokia at qt-info@nokia.com.

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 **

    39 ** $QT_END_LICENSE$

    40 **

    41 ****************************************************************************/

    42 

    43 #include "parser.h"

    44 #include "tokens.h"

    45 #include "errors.h"

    46 

    47 #include <QString>

    48 #include <QStringList>

    49 #include <QDateTime>

    50 

    51 QT_BEGIN_NAMESPACE

    52 

    53 #define TT (tokenStream->currentTokenText().data())

    54 

    55 #define ADVANCE(tk, descr) \

    56 { \

    57   if (tokenStream->lookAhead() != tk) { \

    58     reportError(QString::fromLatin1("'%1' expected found '%2'").arg(QLatin1String(descr)).arg(QString::fromLatin1((tokenStream->currentTokenText().constData())))); \

    59       return false; \

    60   } \

    61   advance(); \

    62 }

    63 

    64 #define ADVANCE_NR(tk, descr) \

    65   do { \

    66     if (tokenStream->lookAhead() != tk) { \

    67         reportError(i18n("'%1' expected found '%2'").arg(QLatin1String(descr)).arg(QString::fromLatin1(tokenStream->currentTokenText().constData()))); \

    68     } \

    69     else \

    70         advance(); \

    71   } while (0)

    72 

    73 #define CHECK(tk, descr) \

    74   do { \

    75     if (tokenStream->lookAhead() != tk) { \

    76         return false; \

    77     } \

    78     advance(); \

    79   } while (0)

    80 

    81 #define MATCH(tk, descr) \

    82   do { \

    83     if (tokenStream->lookAhead() != tk) { \

    84         reportError(Errors::SyntaxError); \

    85         return false; \

    86     } \

    87   } while (0)

    88 

    89 #define UPDATE_POS(_node, start, end) \

    90   do { \

    91       (_node)->setPosition(start, end); \

    92   } while (0)

    93 

    94 #define AST_FROM_TOKEN(node, tk) \

    95     AST *node = CreateNode<AST>(m_pool); \

    96     UPDATE_POS(node, (tk), (tk)+1);

    97 

    98 #define DUMP_AST(node) \

    99   do { \

   100     fprintf(stderr, "\n=================================================\n"); \

   101     for (int i=node->startToken(); i<node->endToken(); ++i) \

   102        fprintf(stderr, "%s", tokenStream->tokenText(i).constData()); \

   103     fprintf(stderr, "\n=================================================\n"); \

   104   } while (0)

   105 

   106 #define RXX_NO_ERROR

   107 

   108 QString i18n(const char *arg)

   109 {

   110     return QLatin1String(arg);

   111 }

   112 

   113 

   114 //@todo remove me

   115 enum

   116 {

   117     OBJC_CLASS,

   118     OBJC_PROTOCOL,

   119     OBJC_ALIAS

   120 };

   121 

   122 Parser::Parser()

   123 {

   124     m_maxProblems = 5;

   125     objcp = false;

   126 }

   127 

   128 Parser::~Parser()

   129 {

   130 }

   131 

   132 TranslationUnitAST *Parser::parse(TokenStreamAdapter::TokenStream *p_tokenStream, pool *p)

   133 {

   134    //tokenStream->rewind(0);

   135     m_pool = p;

   136     tokenStream = p_tokenStream;

   137     TranslationUnitAST *ast = 0;

   138     parseTranslationUnit(ast);

   139     return ast;

   140 }

   141 

   142 /*

   143     Parses a part of the translation unit given by tokenStream. When the number

   144     of nodes in the AST exeeds targetMaxASTnodes, this function will return as

   145     soon as possible. The progress is stored by updating the cursor inside

   146     tokenStream. done is set to true if the parser finished parsing the

   147     tokenStream, and to false otherwise.

   148 */

   149 TranslationUnitAST *Parser::parse(TokenStreamAdapter::TokenStream *p_tokenStream, pool *p, int targetMaxASTNodes, bool &done)

   150 {

   151     m_pool = p;

   152     tokenStream = p_tokenStream;

   153     TranslationUnitAST *ast = 0;

   154     // we always create one node, so target max nodes cannot be < 2.

   155     if (targetMaxASTNodes < 2)

   156         targetMaxASTNodes = 2;

   157 

   158     // Advance past whitespace and comment tokens at the start.

   159     while (tokenStream->isHidden(tokenStream->cursor())) {

   160         tokenStream->nextToken();

   161     }

   162     int start = tokenStream->cursor();

   163 

   164     AST::N = 0;

   165     m_problems = 0;

   166     ast = CreateNode<TranslationUnitAST>(m_pool);

   167     while (tokenStream->lookAhead() && AST::N < targetMaxASTNodes) {

   168         DeclarationAST *def = 0;

   169         int startDecl = tokenStream->cursor();

   170         if (!parseDeclaration(def)) {

   171             // error recovery

   172             if (startDecl == tokenStream->cursor())

   173                 advance(); // skip at least one token

   174             skipUntilDeclaration();

   175         }

   176         ast->addDeclaration(def);

   177     }

   178 

   179     UPDATE_POS(ast, start, tokenStream->cursor());

   180 

   181     done = tokenStream->tokenAtEnd();

   182     return ast;

   183 }

   184 

   185 

   186 bool Parser::reportError(const Error& err)

   187 {

   188 Q_UNUSED(err);

   189 #ifndef RXX_NO_ERROR

   190     if (m_problems < m_maxProblems) {

   191         ++m_problems;

   192         int line=0, col=0;

   193         QByteArray fileName;

   194         tokenStream->getTokenStartPosition(tokenStream->cursor(), &line, &col, &fileName);

   195 

   196         QString s = tokenStream->currentTokenText();

   197         s = s.left(30).trimmed();

   198         if (s.isEmpty())

   199             s = i18n("<eof>");

   200 

   201         if (fileName.isEmpty())

   202             //fileName = m_file->fileName;

   203             fileName = "implement me";

   204 

   205         //        m_driver->addProblem(m_driver->currentFileName(), Problem(err.text.arg(s), line, col));

   206         fprintf(stderr, "%s: error %s at line %d column %d\n",

   207                 fileName.constData(),

   208                 err.text.arg(s).toLatin1().constData(), line, col);

   209     }

   210 #endif // RXX_NO_ERROR

   211     return true;

   212 }

   213 

   214 bool Parser::reportError(const QString& msg)

   215 {

   216 Q_UNUSED(msg);

   217 #ifndef RXX_NO_ERROR

   218     if (m_problems < m_maxProblems) {

   219         ++m_problems;

   220         int line=0, col=0;

   221         QByteArray fileName;

   222         tokenStream->getTokenStartPosition(tokenStream->cursor(), &line, &col, &fileName);

   223 

   224         if (fileName.isEmpty())

   225             //fileName = m_file->fileName;

   226             fileName = "implement me";

   227 

   228         //        m_driver->addProblem(m_driver->currentFileName(), Problem(msg, line, col));

   229         fprintf(stderr, "%s: error %s at line %d column %d\n",

   230                 fileName.constData(),

   231                 msg.toLatin1().constData(), line, col);

   232     }

   233 #endif // RXX_NO_ERROR

   234     return true;

   235 }

   236 

   237 void Parser::syntaxError()

   238 {

   239     (void) reportError(Errors::SyntaxError);

   240 }

   241 

   242 bool Parser::skipUntil(int token)

   243 {

   244     while (tokenStream->lookAhead()) {

   245         if (tokenStream->lookAhead() == token)

   246             return true;

   247 

   248         advance();

   249     }

   250 

   251     return false;

   252 }

   253 

   254 bool Parser::skipUntilDeclaration()

   255 {

   256     while (tokenStream->lookAhead()) {

   257 

   258         switch(tokenStream->lookAhead()) {

   259         case ';':

   260         case '~':

   261         case Token_scope:

   262         case Token_identifier:

   263         case Token_operator:

   264         case Token_char:

   265         case Token_wchar_t:

   266         case Token_bool:

   267         case Token_short:

   268         case Token_int:

   269         case Token_long:

   270         case Token_signed:

   271         case Token_unsigned:

   272         case Token_float:

   273         case Token_double:

   274         case Token_void:

   275         case Token_extern:

   276         case Token_namespace:

   277         case Token_using:

   278         case Token_typedef:

   279         case Token_asm:

   280         case Token_template:

   281         case Token_export:

   282 

   283         case Token_const:       // cv

   284         case Token_volatile:    // cv

   285 

   286         case Token_public:

   287         case Token_protected:

   288         case Token_private:

   289         case Token_signals:      // Qt

   290         case Token_slots:        // Qt

   291               return true;

   292 

   293         default:

   294             advance();

   295         }

   296     }

   297 

   298     return false;

   299 }

   300 

   301 bool Parser::skipUntilStatement()

   302 {

   303     while (tokenStream->lookAhead()) {

   304         switch(tokenStream->lookAhead()) {

   305                 case ';':

   306                 case '{':

   307                 case '}':

   308                 case Token_const:

   309                 case Token_volatile:

   310                 case Token_identifier:

   311                 case Token_case:

   312                 case Token_default:

   313                 case Token_if:

   314                 case Token_switch:

   315                 case Token_while:

   316                 case Token_do:

   317                 case Token_for:

   318                 case Token_break:

   319                 case Token_continue:

   320                 case Token_return:

   321                 case Token_goto:

   322                 case Token_try:

   323                 case Token_catch:

   324                 case Token_throw:

   325                 case Token_char:

   326                 case Token_wchar_t:

   327                 case Token_bool:

   328                 case Token_short:

   329                 case Token_int:

   330                 case Token_long:

   331                 case Token_signed:

   332                 case Token_unsigned:

   333                 case Token_float:

   334                 case Token_double:

   335                 case Token_void:

   336                 case Token_class:

   337                 case Token_struct:

   338                 case Token_union:

   339                 case Token_enum:

   340                 case Token_scope:

   341                 case Token_template:

   342                 case Token_using:

   343                     return true;

   344 

   345             default:

   346                   advance();

   347         }

   348     }

   349 

   350     return false;

   351 }

   352 

   353 bool Parser::skip(int l, int r)

   354 {

   355     int count = 0;

   356     while (tokenStream->lookAhead()) {

   357         int tk = tokenStream->lookAhead();

   358 

   359         if (tk == l)

   360             ++count;

   361         else if (tk == r)

   362             --count;

   363         else if (l != '{' && (tk == '{' || tk == '}' || tk == ';'))

   364             return false;

   365 

   366         if (count == 0)

   367             return true;

   368 

   369         advance();

   370     }

   371 

   372     return false;

   373 }

   374 

   375 bool Parser::skipCommaExpression(AbstractExpressionAST *&node)

   376 {

   377 #ifndef RXX_NO_PARSE_EXPRESSION

   378     return parseCommaExpression(node);

   379 #else

   380     int start = tokenStream->cursor();

   381 

   382     AbstractExpressionAST *expr = 0;

   383     if (!skipExpression(expr))

   384         return false;

   385 

   386     while (tokenStream->lookAhead() == ',') {

   387         advance();

   388 

   389         if (!skipExpression(expr)) {

   390             reportError(i18n("expression expected"));

   391             return false;

   392         }

   393     }

   394 

   395     AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool);

   396     UPDATE_POS(ast, start, tokenStream->cursor());

   397     node = ast;

   398 

   399     return true;

   400 #endif // RXX_NO_PARSE_EXPRESSION

   401 }

   402 

   403 bool Parser::skipExpression(AbstractExpressionAST *&node)

   404 {

   405 #ifndef RXX_NO_PARSE_EXPRESSION

   406     return parseExpression(node);

   407 #else

   408     int start = tokenStream->cursor();

   409     int count = 0;

   410 

   411     while (tokenStream->lookAhead()) {

   412         int tk = tokenStream->lookAhead();

   413 

   414         switch(tk) {

   415         case '(':

   416         case '[':

   417         case '{':

   418             ++count;

   419             advance();

   420             break;

   421 

   422         case ']':

   423         case ')':

   424         case '}':

   425             if (count == 0) {

   426                 AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool);

   427                 UPDATE_POS(ast, start, tokenStream->cursor());

   428                 node = ast;

   429                 return true;

   430             }

   431             --count;

   432             advance();

   433             break;

   434 

   435         case Token_struct:

   436         case Token_union:

   437         case Token_class: {

   438             int c = tokenStream->cursor();

   439             TypeSpecifierAST *spec = 0;

   440             if (!parseClassSpecifier(spec))

   441                 tokenStream->rewind(c + 1);

   442         }

   443         break;

   444 

   445         case ',':

   446         case ';':

   447         case Token_case:

   448         case Token_default:

   449         case Token_if:

   450         case Token_while:

   451         case Token_do:

   452         case Token_for:

   453         case Token_break:

   454         case Token_continue:

   455         case Token_return:

   456         case Token_goto:

   457         {

   458             if ((tk == ',' || tk == ';') && count > 0) {

   459                 advance();

   460                 break;

   461             }

   462 

   463             AbstractExpressionAST *ast = CreateNode<AbstractExpressionAST>(m_pool);

   464             UPDATE_POS(ast, start, tokenStream->cursor());

   465             node = ast;

   466         }

   467         return true;

   468 

   469         default:

   470             advance();

   471         }

   472     }

   473 

   474     return false;

   475 #endif // RXX_NO_PARSE_EXPRESSION

   476 }

   477 

   478 bool Parser::parseName(NameAST *&node, bool parseTemplateId)

   479 {

   480     AST *winDeclSpec = 0;

   481     parseWinDeclSpec(winDeclSpec);

   482 

   483     int start = tokenStream->cursor();

   484 

   485     NameAST *ast = CreateNode<NameAST>(m_pool);

   486 

   487     if (tokenStream->lookAhead() == Token_scope) {

   488         ast->setGlobal(true);

   489         advance();

   490     }

   491 

   492     int idx = tokenStream->cursor();

   493 

   494     while (true) {

   495         ClassOrNamespaceNameAST *n = 0;

   496         if (!parseUnqualifiedName(n))

   497             return false;

   498 

   499         if (tokenStream->lookAhead() == Token_scope) {

   500             advance();

   501             ast->addClassOrNamespaceName(n);

   502             if (tokenStream->lookAhead() == Token_template)

   503                 advance(); /// skip optional template     #### @todo CHECK

   504         } else if (!parseTemplateId && n) {

   505             tokenStream->rewind(n->startToken());

   506             parseUnqualifiedName(n, parseTemplateId);

   507             ast->setUnqualifiedName(n);

   508             break;

   509         } else {

   510             ast->setUnqualifiedName(n);

   511             break;

   512         }

   513     }

   514 

   515     if (idx == tokenStream->cursor())

   516         return false;

   517 

   518     UPDATE_POS(ast, start, tokenStream->cursor());

   519     node = ast;

   520 

   521     return true;

   522 }

   523 

   524 bool Parser::parseTranslationUnit(TranslationUnitAST *&node)

   525 {

   526     QTime t;

   527     t.start();

   528 

   529     advance();

   530     int start = tokenStream->cursor();

   531 

   532     m_problems = 0;

   533     TranslationUnitAST *tun = CreateNode<TranslationUnitAST>(m_pool);

   534     node = tun;

   535     while (tokenStream->lookAhead()) {

   536         DeclarationAST *def = 0;

   537         int startDecl = tokenStream->cursor();

   538         if (!parseDeclaration(def)) {

   539             // error recovery

   540             if (startDecl == tokenStream->cursor())

   541                 advance(); // skip at least one token

   542             skipUntilDeclaration();

   543         }

   544         node->addDeclaration(def);

   545     }

   546 

   547     UPDATE_POS(node, start, tokenStream->cursor());

   548 

   549     return m_problems == 0;

   550 }

   551 

   552 bool Parser::parseDeclaration(DeclarationAST *&node)

   553 {

   554     int start = tokenStream->cursor();

   555 

   556     switch(tokenStream->lookAhead()) {

   557 

   558     case ';':

   559         advance();

   560         return true;

   561 

   562     case Token_extern:

   563         return parseLinkageSpecification(node);

   564 

   565     case Token_namespace:

   566         return parseNamespace(node);

   567 

   568     case Token_using:

   569         return parseUsing(node);

   570 

   571     case Token_typedef:

   572         return parseTypedef(node);

   573 

   574     case Token_asm:

   575         return parseAsmDefinition(node);

   576 

   577     case Token_template:

   578     case Token_export:

   579         return parseTemplateDeclaration(node);

   580 

   581     default:

   582         {

   583             // tokenStream->rewind(start);

   584 

   585             if (objcp && parseObjcDef(node))

   586                 return true;

   587 

   588             tokenStream->rewind(start);

   589 

   590             AST *storageSpec = 0;

   591             parseStorageClassSpecifier(storageSpec);

   592 

   593             AST *cv = 0;

   594             parseCvQualify(cv);

   595 

   596             TypeSpecifierAST *spec = 0;

   597             if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) {

   598                 spec->setCvQualify(cv);

   599 

   600                 AST *cv2 = 0;

   601                 parseCvQualify(cv2);

   602                 spec->setCv2Qualify(cv2);

   603 

   604                 InitDeclaratorListAST *declarators = 0;

   605                 parseInitDeclaratorList(declarators);

   606                 ADVANCE(';', ";");

   607 

   608                 SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(m_pool);

   609                 ast->setStorageSpecifier(storageSpec);

   610                 ast->setTypeSpec(spec);

   611                 ast->setInitDeclaratorList(declarators);

   612                 UPDATE_POS(ast, start, tokenStream->cursor());

   613                 node = ast;

   614 

   615                 return true;

   616             }

   617 

   618             tokenStream->rewind(start);

   619             return parseDeclarationInternal(node);

   620         }

   621 

   622     } // end switch

   623 }

   624 

   625 bool Parser::parseLinkageSpecification(DeclarationAST *&node)

   626 {

   627     int start = tokenStream->cursor();

   628 

   629     if (tokenStream->lookAhead() != Token_extern) {

   630         return false;

   631     }

   632     advance();

   633 

   634     LinkageSpecificationAST *ast = CreateNode<LinkageSpecificationAST>(m_pool);

   635 

   636     int startExternType = tokenStream->cursor();

   637     if (tokenStream->lookAhead() == Token_string_literal) {

   638         advance();

   639         AST *externType = CreateNode<AST>(m_pool);

   640         UPDATE_POS(externType, startExternType, tokenStream->cursor());

   641 

   642         ast->setExternType(externType);

   643     }

   644 

   645     if (tokenStream->lookAhead() == '{') {

   646         LinkageBodyAST *linkageBody = 0;

   647         parseLinkageBody(linkageBody);

   648         ast->setLinkageBody(linkageBody);

   649     } else {

   650         DeclarationAST *decl = 0;

   651         if (!parseDeclaration(decl)) {

   652             reportError(i18n("Declaration syntax error"));

   653         }

   654         ast->setDeclaration(decl);

   655     }

   656 

   657     UPDATE_POS(ast, start, tokenStream->cursor());

   658 

   659     node = ast;

   660 

   661     return true;

   662 }

   663 

   664 bool Parser::parseLinkageBody(LinkageBodyAST *&node)

   665 {

   666 

   667     int start = tokenStream->cursor();

   668 

   669     if (tokenStream->lookAhead() != '{') {

   670         return false;

   671     }

   672     advance();

   673 

   674     LinkageBodyAST *lba = CreateNode<LinkageBodyAST>(m_pool);

   675     node = lba;

   676 

   677     while (tokenStream->lookAhead()) {

   678         int tk = tokenStream->lookAhead();

   679 

   680         if (tk == '}')

   681             break;

   682 

   683         DeclarationAST *def = 0;

   684         int startDecl = tokenStream->cursor();

   685         if (parseDeclaration(def)) {

   686             node->addDeclaration(def);

   687         } else {

   688             // error recovery

   689             if (startDecl == tokenStream->cursor())

   690                 advance(); // skip at least one token

   691             skipUntilDeclaration();

   692         }

   693     }

   694 

   695     if (tokenStream->lookAhead() != '}') {

   696         reportError(i18n("} expected"));

   697     } else

   698         advance();

   699 

   700     UPDATE_POS(node, start, tokenStream->cursor());

   701     return true;

   702 }

   703 

   704 bool Parser::parseNamespace(DeclarationAST *&node)

   705 {

   706     int start = tokenStream->cursor();

   707 

   708     if (tokenStream->lookAhead() != Token_namespace) {

   709         return false;

   710     }

   711     advance();

   712 

   713     int startNamespaceName = tokenStream->cursor();

   714     if (tokenStream->lookAhead() == Token_identifier) {

   715         advance();

   716     }

   717     AST *namespaceName = CreateNode<AST>(m_pool);

   718     UPDATE_POS(namespaceName, startNamespaceName, tokenStream->cursor());

   719 

   720     if (tokenStream->lookAhead() == '=') {

   721         // namespace alias

   722         advance();

   723 

   724         NameAST *name = 0;

   725         if (parseName(name)) {

   726             ADVANCE(';', ";");

   727 

   728             NamespaceAliasAST *ast = CreateNode<NamespaceAliasAST>(m_pool);

   729             ast->setNamespaceName(namespaceName);

   730             ast->setAliasName(name);

   731             UPDATE_POS(ast, start, tokenStream->cursor());

   732             node = ast;

   733             return true;

   734         } else {

   735             reportError(i18n("namespace expected"));

   736             return false;

   737         }

   738     } else if (tokenStream->lookAhead() != '{') {

   739         reportError(i18n("{ expected"));

   740         return false;

   741     }

   742 

   743     NamespaceAST *ast = CreateNode<NamespaceAST>(m_pool);

   744     ast->setNamespaceName(namespaceName);

   745 

   746     LinkageBodyAST *linkageBody = 0;

   747     parseLinkageBody(linkageBody);

   748 

   749     ast->setLinkageBody(linkageBody);

   750     UPDATE_POS(ast, start, tokenStream->cursor());

   751     node = ast;

   752 

   753     return true;

   754 }

   755 

   756 bool Parser::parseUsing(DeclarationAST *&node)

   757 {

   758     int start = tokenStream->cursor();

   759 

   760     if (tokenStream->lookAhead() != Token_using) {

   761         return false;

   762     }

   763     advance();

   764 

   765     if (tokenStream->lookAhead() == Token_namespace) {

   766         if (!parseUsingDirective(node)) {

   767             return false;

   768         }

   769         UPDATE_POS(node, start, tokenStream->cursor());

   770         return true;

   771     }

   772 

   773     UsingAST *ast = CreateNode<UsingAST>(m_pool);

   774 

   775     int startTypeName = tokenStream->cursor();

   776     if (tokenStream->lookAhead() == Token_typename) {

   777         advance();

   778         AST *tn = CreateNode<AST>(m_pool);

   779         UPDATE_POS(tn, startTypeName, tokenStream->cursor());

   780         ast->setTypeName(tn);

   781     }

   782 

   783     NameAST *name = 0;

   784     if (!parseName(name))

   785         return false;

   786 

   787     ast->setName(name);

   788 

   789     ADVANCE(';', ";");

   790 

   791     UPDATE_POS(ast, start, tokenStream->cursor());

   792     node = ast;

   793 

   794     return true;

   795 }

   796 

   797 bool Parser::parseUsingDirective(DeclarationAST *&node)

   798 {

   799     int start = tokenStream->cursor();

   800 

   801     if (tokenStream->lookAhead() != Token_namespace) {

   802         return false;

   803     }

   804     advance();

   805 

   806     NameAST *name = 0;

   807     if (!parseName(name)) {

   808         reportError(i18n("Namespace name expected"));

   809         return false;

   810     }

   811 

   812     ADVANCE(';', ";");

   813 

   814     UsingDirectiveAST *ast = CreateNode<UsingDirectiveAST>(m_pool);

   815     ast->setName(name);

   816     UPDATE_POS(ast, start, tokenStream->cursor());

   817     node = ast;

   818 

   819     return true;

   820 }

   821 

   822 

   823 bool Parser::parseOperatorFunctionId(AST *&node)

   824 {

   825     int start = tokenStream->cursor();

   826 

   827     if (tokenStream->lookAhead() != Token_operator) {

   828         return false;

   829     }

   830     advance();

   831 

   832     AST *op = 0;

   833     if (parseOperator(op)) {

   834         AST *asn = CreateNode<AST>(m_pool);

   835         node = asn;

   836         UPDATE_POS(node, start, tokenStream->cursor());

   837         return true;

   838     } else {

   839         // parse cast operator

   840         AST *cv = 0;

   841         parseCvQualify(cv);

   842 

   843         TypeSpecifierAST *spec = 0;

   844         if (!parseSimpleTypeSpecifier(spec)) {

   845             syntaxError();

   846             return false;

   847         }

   848         spec->setCvQualify(cv);

   849 

   850         AST *cv2 = 0;

   851         parseCvQualify(cv2);

   852         spec->setCv2Qualify(cv2);

   853 

   854         AST *ptrOp = 0;

   855         while (parsePtrOperator(ptrOp))

   856               ;

   857 

   858         AST *asn = CreateNode<AST>(m_pool);

   859         node = asn;

   860         UPDATE_POS(node, start, tokenStream->cursor());

   861         return true;

   862     }

   863 }

   864 

   865 bool Parser::parseTemplateArgumentList(TemplateArgumentListAST *&node, bool reportError)

   866 {

   867     int start = tokenStream->cursor();

   868 

   869     TemplateArgumentListAST *ast = CreateNode<TemplateArgumentListAST>(m_pool);

   870 

   871     AST *templArg = 0;

   872     if (!parseTemplateArgument(templArg))

   873         return false;

   874     ast->addArgument(templArg);

   875 

   876     while (tokenStream->lookAhead() == ',') {

   877         advance();

   878 

   879         if (!parseTemplateArgument(templArg)) {

   880             if (reportError) {

   881                syntaxError();

   882                break;

   883             } else

   884                return false;

   885         }

   886         ast->addArgument(templArg);

   887     }

   888 

   889     UPDATE_POS(ast, start, tokenStream->cursor());

   890     node = ast;

   891 

   892     return true;

   893 }

   894 

   895 bool Parser::parseTypedef(DeclarationAST *&node)

   896 {

   897     int start = tokenStream->cursor();

   898 

   899     if (tokenStream->lookAhead() != Token_typedef) {

   900         return false;

   901     }

   902     advance();

   903 

   904     TypeSpecifierAST *spec = 0;

   905     if (!parseTypeSpecifierOrClassSpec(spec)) {

   906         reportError(i18n("Need a type specifier to declare"));

   907         return false;

   908     }

   909 

   910     InitDeclaratorListAST *declarators = 0;

   911     if (!parseInitDeclaratorList(declarators)) {

   912         //reportError(i18n("Need an identifier to declare"));

   913         //return false;

   914     }

   915 

   916     ADVANCE(';', ";");

   917 

   918     TypedefAST *ast = CreateNode<TypedefAST>(m_pool);

   919     ast->setTypeSpec(spec);

   920     ast->setInitDeclaratorList(declarators);

   921     UPDATE_POS(ast, start, tokenStream->cursor());

   922     node = ast;

   923 

   924     return true;

   925 }

   926 

   927 bool Parser::parseAsmDefinition(DeclarationAST *&node)

   928 {

   929     int start = tokenStream->cursor();

   930 

   931     ADVANCE(Token_asm, "asm");

   932 

   933     AST *cv = 0;

   934     parseCvQualify(cv);

   935 

   936     skip('(', ')');

   937     advance();

   938     ADVANCE(';', ";");

   939 

   940     DeclarationAST *ast = CreateNode<DeclarationAST>(m_pool);

   941     UPDATE_POS(ast, start, tokenStream->cursor());

   942     node = ast;

   943 

   944     return true;

   945 }

   946 

   947 bool Parser::parseTemplateDeclaration(DeclarationAST *&node)

   948 {

   949     int start = tokenStream->cursor();

   950 

   951     AST *exp = 0;

   952 

   953     int startExport = tokenStream->cursor();

   954     if (tokenStream->lookAhead() == Token_export) {

   955         advance();

   956         AST *n = CreateNode<AST>(m_pool);

   957         UPDATE_POS(n, startExport, tokenStream->cursor());

   958         exp = n;

   959     }

   960 

   961     if (tokenStream->lookAhead() != Token_template) {

   962         return false;

   963     }

   964     advance();

   965 

   966     TemplateParameterListAST *params = 0;

   967     if (tokenStream->lookAhead() == '<') {

   968         advance();

   969         parseTemplateParameterList(params);

   970 

   971         ADVANCE('>', ">");

   972     }

   973 

   974     DeclarationAST *def = 0;

   975     if (!parseDeclaration(def)) {

   976         reportError(i18n("expected a declaration"));

   977     }

   978 

   979     TemplateDeclarationAST *ast = CreateNode<TemplateDeclarationAST>(m_pool);

   980     ast->setExported(exp);

   981     ast->setTemplateParameterList(params);

   982     ast->setDeclaration(def);

   983     UPDATE_POS(ast, start, tokenStream->cursor());

   984     node = ast;

   985 

   986     return true;

   987 }

   988 

   989 bool Parser::parseOperator(AST *&/*node*/)

   990 {

   991     QString text(QString::fromLatin1(tokenStream->currentTokenText().constData()));

   992 

   993     switch(tokenStream->lookAhead()) {

   994     case Token_new:

   995     case Token_delete:

   996         advance();

   997         if (tokenStream->lookAhead() == '[' && tokenStream->lookAhead(1) == ']') {

   998             advance();

   999             advance();

  1000             text += QLatin1String("[]");

  1001         }

  1002         return true;

  1003 

  1004     case '+':

  1005     case '-':

  1006     case '*':

  1007     case '/':

  1008     case '%':

  1009     case '^':

  1010     case '&':

  1011     case '|':

  1012     case '~':

  1013     case '!':

  1014     case '=':

  1015     case '<':

  1016     case '>':

  1017     case ',':

  1018     case Token_assign:

  1019     case Token_shift:

  1020     case Token_eq:

  1021     case Token_not_eq:

  1022     case Token_leq:

  1023     case Token_geq:

  1024     case Token_and:

  1025     case Token_or:

  1026     case Token_incr:

  1027     case Token_decr:

  1028     case Token_ptrmem:

  1029     case Token_arrow:

  1030         advance();

  1031         return true;

  1032 

  1033     default:

  1034         if (tokenStream->lookAhead() == '(' && tokenStream->lookAhead(1) == ')') {

  1035             advance();

  1036             advance();

  1037             return true;

  1038         } else if (tokenStream->lookAhead() == '[' && tokenStream->lookAhead(1) == ']') {

  1039             advance();

  1040             advance();

  1041             return true;

  1042         }

  1043     }

  1044 

  1045     return false;

  1046 }

  1047 

  1048 bool Parser::parseCvQualify(AST *&node)

  1049 {

  1050     int start = tokenStream->cursor();

  1051 

  1052     AST *ast = CreateNode<AST>(m_pool);

  1053 

  1054     int n = 0;

  1055     while (tokenStream->lookAhead()) {

  1056         int tk = tokenStream->lookAhead();

  1057         if (tk == Token_const || tk == Token_volatile) {

  1058             ++n;

  1059             int startWord = tokenStream->cursor();

  1060             advance();

  1061             AST *word = CreateNode<AST>(m_pool);

  1062             UPDATE_POS(word, startWord, tokenStream->cursor());

  1063             word->setParent(ast);

  1064         } else

  1065             break;

  1066     }

  1067 

  1068     if (n == 0)

  1069         return false;

  1070 

  1071 

  1072     UPDATE_POS(ast, start, tokenStream->cursor());

  1073 

  1074     node = ast;

  1075     return true;

  1076 }

  1077 

  1078 bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST *&node, bool onlyIntegral)

  1079 {

  1080     int start = tokenStream->cursor();

  1081     bool isIntegral = false;

  1082     bool done = false;

  1083 

  1084     while (!done) {

  1085         switch(tokenStream->lookAhead()) {

  1086             case Token_char:

  1087             case Token_wchar_t:

  1088             case Token_bool:

  1089             case Token_short:

  1090             case Token_int:

  1091             case Token_long:

  1092             case Token_signed:

  1093             case Token_unsigned:

  1094             case Token_float:

  1095             case Token_double:

  1096             case Token_void:

  1097                 isIntegral = true;

  1098                 advance();

  1099                 break;

  1100 

  1101             default:

  1102                 done = true;

  1103         }

  1104     }

  1105 

  1106     TypeSpecifierAST *ast = CreateNode<TypeSpecifierAST>(m_pool);

  1107     if (isIntegral) {

  1108         ClassOrNamespaceNameAST *cl = CreateNode<ClassOrNamespaceNameAST>(m_pool);

  1109 

  1110         AST *n = CreateNode<AST>(m_pool);

  1111         UPDATE_POS(n, start, tokenStream->cursor());

  1112         cl->setName(n);

  1113         UPDATE_POS(cl, start, tokenStream->cursor());

  1114 

  1115         NameAST *name = CreateNode<NameAST>(m_pool);

  1116         name->setUnqualifiedName(cl);

  1117         UPDATE_POS(name, start, tokenStream->cursor());

  1118         ast->setName(name);

  1119     } else if (tokenStream->lookAhead() == Token___typeof) {

  1120         advance();

  1121         if (tokenStream->lookAhead() == '(') {

  1122             advance();

  1123             TypeIdAST *typeId = 0;

  1124             parseTypeId(typeId);

  1125             ADVANCE(')', ")");

  1126         } else {

  1127             AbstractExpressionAST *e = 0;

  1128             parseUnaryExpression(e);

  1129         }

  1130     } else if (onlyIntegral) {

  1131         tokenStream->rewind(start);

  1132         return false;

  1133     } else {

  1134         NameAST *name = 0;