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

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 // Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>

    42 //

    43 // Permission is hereby granted, free of charge, to any person obtaining a copy

    44 // of this software and associated documentation files (the "Software"), to deal

    45 // in the Software without restriction, including without limitation the rights

    46 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    47 // copies of the Software, and to permit persons to whom the Software is

    48 // furnished to do so, subject to the following conditions:

    49 //

    50 // The above copyright notice and this permission notice shall be included in

    51 // all copies or substantial portions of the Software.

    52 //

    53 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    54 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    55 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    56 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    57 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    58 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    59 // THE SOFTWARE.

    60 

    61 #include "Parser.h"

    62 #include "Token.h"

    63 #include "Lexer.h"

    64 #include "Control.h"

    65 #include "AST.h"

    66 #include "Literals.h"

    67 #include "ObjectiveCTypeQualifiers.h"

    68 #include <cstdio> // for putchar

    69 #ifdef ICHECK_BUILD

    70 #  include <QString>

    71 #endif

    72 

    73 #define CPLUSPLUS_NO_DEBUG_RULE

    74 #define MAX_EXPRESSION_DEPTH 100

    75 

    76 using namespace CPlusPlus;

    77 

    78 namespace {

    79 

    80 class DebugRule {

    81     const char *name;

    82     static int depth;

    83 

    84 public:

    85     DebugRule(const char *name)

    86         : name(name)

    87     {

    88         for (int i = 0; i < depth; ++i)

    89             putchar(' ');

    90 

    91         ++depth;

    92         printf("%s\n", name);

    93     }

    94 

    95     ~DebugRule()

    96     { --depth; }

    97 };

    98 

    99 int DebugRule::depth = 0;

   100 

   101 inline bool lookAtAssignmentOperator(int tokenKind)

   102 {

   103     switch (tokenKind) {

   104     case T_EQUAL:

   105     case T_AMPER_EQUAL:

   106     case T_CARET_EQUAL:

   107     case T_SLASH_EQUAL:

   108     case T_GREATER_GREATER_EQUAL:

   109     case T_LESS_LESS_EQUAL:

   110     case T_MINUS_EQUAL:

   111     case T_PERCENT_EQUAL:

   112     case T_PIPE_EQUAL:

   113     case T_PLUS_EQUAL:

   114     case T_STAR_EQUAL:

   115     case T_TILDE_EQUAL:

   116         return true;

   117     default:

   118         return false;

   119     } // switch

   120 }

   121 

   122 namespace Prec {

   123 enum {

   124     Unknown         = 0,

   125     Comma           = 1,

   126     Assignment      = 2,

   127     Conditional     = 3,

   128     LogicalOr       = 4,

   129     LogicalAnd      = 5,

   130     InclusiveOr     = 6,

   131     ExclusiveOr     = 7,

   132     And             = 8,

   133     Equality        = 9,

   134     Relational      = 10,

   135     Shift           = 11,

   136     Additive        = 12,

   137     Multiplicative  = 13,

   138     PointerToMember = 14

   139 };

   140 } // end of namespace Precedece

   141 

   142 inline int precedence(int tokenKind, bool templateArguments)

   143 {

   144     // ### this will/might need some tuning for C++0x

   145     // (see: [temp.names]p3)

   146     if (templateArguments && tokenKind == T_GREATER)

   147         return -1;

   148 

   149     if (lookAtAssignmentOperator(tokenKind))

   150         return Prec::Assignment;

   151 

   152     switch (tokenKind) {

   153     case T_COMMA:           return Prec::Comma;

   154     case T_QUESTION:        return Prec::Conditional;

   155     case T_PIPE_PIPE:       return Prec::LogicalOr;

   156     case T_AMPER_AMPER:     return Prec::LogicalAnd;

   157     case T_PIPE:            return Prec::InclusiveOr;

   158     case T_CARET:           return Prec::ExclusiveOr;

   159     case T_AMPER:           return Prec::And;

   160     case T_EQUAL_EQUAL:

   161     case T_EXCLAIM_EQUAL:   return Prec::Equality;

   162     case T_GREATER:

   163     case T_LESS:

   164     case T_LESS_EQUAL:

   165     case T_GREATER_EQUAL:   return Prec::Relational;

   166     case T_LESS_LESS:

   167     case T_GREATER_GREATER: return Prec::ExclusiveOr;

   168     case T_PLUS:

   169     case T_MINUS:           return Prec::Additive;

   170     case T_STAR:

   171     case T_SLASH:

   172     case T_PERCENT:         return Prec::Multiplicative;

   173     case T_ARROW_STAR:

   174     case T_DOT_STAR:        return Prec::PointerToMember;

   175     default:                return Prec::Unknown;

   176     }

   177 }

   178 

   179 inline bool isBinaryOperator(int tokenKind)

   180 { return precedence(tokenKind, false) != Prec::Unknown; }

   181 

   182 inline bool isRightAssociative(int tokenKind)

   183 {

   184     const int prec = precedence(tokenKind, false);

   185     return prec == Prec::Conditional || prec == Prec::Assignment;

   186 }

   187 

   188 } // end of anonymous namespace

   189 

   190 #ifndef CPLUSPLUS_NO_DEBUG_RULE

   191 #  define DEBUG_THIS_RULE() DebugRule __debug_rule__(__func__)

   192 #else

   193 #  define DEBUG_THIS_RULE() do {} while (0)

   194 #endif

   195 

   196 #define PARSE_EXPRESSION_WITH_OPERATOR_PRECEDENCE(node, minPrecedence) { \

   197     if (LA() == T_THROW) { \

   198         if (!parseThrowExpression(node)) \

   199             return false; \

   200     } else if (!parseCastExpression(node)) \

   201         return false; \

   202     \

   203     parseExpressionWithOperatorPrecedence(node, minPrecedence); \

   204     return true; \

   205 }

   206 

   207 class Parser::Rewind

   208 {

   209     Parser *_parser;

   210     MemoryPool::State _state;

   211 

   212 public:

   213     inline Rewind(Parser *parser)

   214         : _parser(parser) {}

   215 

   216     inline void operator()(unsigned tokenIndex)

   217     { rewind(tokenIndex); }

   218 

   219     inline void mark()

   220     { _state = _parser->_pool->state(); }

   221 

   222     inline void rewind(unsigned tokenIndex)

   223     {

   224         _parser->rewind(tokenIndex);

   225 

   226         if (_state.isValid())

   227             _parser->_pool->rewind(_state);

   228     }

   229 };

   230 

   231 Parser::Parser(TranslationUnit *unit)

   232     : _translationUnit(unit),

   233       _control(_translationUnit->control()),

   234       _pool(_translationUnit->memoryPool()),

   235       _tokenIndex(1),

   236       _templateArguments(0),

   237       _qtMocRunEnabled(false),

   238       _objCEnabled(false),

   239       _inFunctionBody(false),

   240       _inObjCImplementationContext(false),

   241       _expressionDepth(0)

   242 { }

   243 

   244 Parser::~Parser()

   245 { }

   246 

   247 bool Parser::qtMocRunEnabled() const

   248 { return _qtMocRunEnabled; }

   249 

   250 void Parser::setQtMocRunEnabled(bool onoff)

   251 { _qtMocRunEnabled = onoff; }

   252 

   253 bool Parser::objCEnabled() const

   254 { return _objCEnabled; }

   255 

   256 void Parser::setObjCEnabled(bool onoff)

   257 { _objCEnabled = onoff; }

   258 

   259 bool Parser::switchTemplateArguments(bool templateArguments)

   260 {

   261     bool previousTemplateArguments = _templateArguments;

   262     _templateArguments = templateArguments;

   263     return previousTemplateArguments;

   264 }

   265 

   266 bool Parser::blockErrors(bool block)

   267 { return _translationUnit->blockErrors(block); }

   268 

   269 bool Parser::skipUntil(int token)

   270 {

   271     while (int tk = LA()) {

   272         if (tk == token)

   273             return true;

   274 

   275         consumeToken();

   276     }

   277 

   278     return false;

   279 }

   280 

   281 void Parser::skipUntilDeclaration()

   282 {

   283     for (; ; consumeToken()) {

   284         switch (LA()) {

   285         case T_EOF_SYMBOL:

   286 

   287         // names

   288         case T_IDENTIFIER:

   289         case T_COLON_COLON:

   290         case T_TILDE:

   291         case T_OPERATOR:

   292 

   293         // empty declaration

   294         case T_SEMICOLON:

   295 

   296         // member specification

   297         case T_USING:

   298         case T_TEMPLATE:

   299         case T_PUBLIC:

   300         case T_PROTECTED:

   301         case T_PRIVATE:

   302         case T_Q_SIGNALS:

   303         case T_Q_SLOTS:

   304 

   305         // declarations

   306         case T_ENUM:

   307         case T_NAMESPACE:

   308         case T_ASM:

   309         case T_EXPORT:

   310         case T_AT_CLASS:

   311         case T_AT_INTERFACE:

   312         case T_AT_PROTOCOL:

   313         case T_AT_IMPLEMENTATION:

   314         case T_AT_END:

   315             return;

   316 

   317         default:

   318             if (lookAtBuiltinTypeSpecifier() || lookAtClassKey() ||

   319                 lookAtFunctionSpecifier() || lookAtStorageClassSpecifier())

   320                 return;

   321         } // switch

   322     }

   323 }

   324 

   325 bool Parser::skipUntilStatement()

   326 {

   327     while (int tk = LA()) {

   328         switch (tk) {

   329             case T_SEMICOLON:

   330             case T_LBRACE:

   331             case T_RBRACE:

   332             case T_CONST:

   333             case T_VOLATILE:

   334             case T_IDENTIFIER:

   335             case T_CASE:

   336             case T_DEFAULT:

   337             case T_IF:

   338             case T_SWITCH:

   339             case T_WHILE:

   340             case T_DO:

   341             case T_FOR:

   342             case T_BREAK:

   343             case T_CONTINUE:

   344             case T_RETURN:

   345             case T_GOTO:

   346             case T_TRY:

   347             case T_CATCH:

   348             case T_THROW:

   349             case T_CHAR:

   350             case T_WCHAR_T:

   351             case T_BOOL:

   352             case T_SHORT:

   353             case T_INT:

   354             case T_LONG:

   355             case T_SIGNED:

   356             case T_UNSIGNED:

   357             case T_FLOAT:

   358             case T_DOUBLE:

   359             case T_VOID:

   360             case T_CLASS:

   361             case T_STRUCT:

   362             case T_UNION:

   363             case T_ENUM:

   364             case T_COLON_COLON:

   365             case T_TEMPLATE:

   366             case T_USING:

   367                 return true;

   368 

   369             case T_AT_SYNCHRONIZED:

   370                 if (objCEnabled())

   371                     return true;

   372 

   373             default:

   374                 consumeToken();

   375         }

   376     }

   377 

   378     return false;

   379 }

   380 

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

   382 {

   383     int count = 0;

   384 

   385     while (int tk = LA()) {

   386         if (tk == l)

   387             ++count;

   388         else if (tk == r)

   389             --count;

   390         else if (l != T_LBRACE && (tk == T_LBRACE ||

   391                                    tk == T_RBRACE ||

   392                                    tk == T_SEMICOLON))

   393             return false;

   394 

   395         if (count == 0)

   396             return true;

   397 

   398         consumeToken();

   399     }

   400 

   401     return false;

   402 }

   403 

   404 void Parser::match(int kind, unsigned *token)

   405 {

   406     if (LA() == kind)

   407         *token = consumeToken();

   408     else {

   409         *token = 0;

   410         _translationUnit->error(_tokenIndex, "expected token `%s' got `%s'",

   411                                 Token::name(kind), tok().spell());

   412     }

   413 }

   414 

   415 bool Parser::parseClassOrNamespaceName(NameAST *&node)

   416 {

   417     DEBUG_THIS_RULE();

   418     if (LA() == T_IDENTIFIER) {

   419         unsigned identifier_token = cursor();

   420 

   421         if (LA(2) == T_LESS && parseTemplateId(node) && LA() == T_COLON_COLON)

   422             return true;

   423 

   424         rewind(identifier_token);

   425 

   426         if (LA(2) == T_COLON_COLON) {

   427             SimpleNameAST *ast = new (_pool) SimpleNameAST;

   428             ast->identifier_token = consumeToken();

   429             node = ast;

   430             return true;

   431         }

   432     } else if (LA() == T_TEMPLATE) {

   433         unsigned template_token = consumeToken();

   434         if (parseTemplateId(node))

   435             return true;

   436         rewind(template_token);

   437     }

   438     return false;

   439 }

   440 

   441 bool Parser::parseTemplateId(NameAST *&node)

   442 {

   443     DEBUG_THIS_RULE();

   444 

   445     const unsigned start = cursor();

   446 

   447     if (LA() == T_IDENTIFIER && LA(2) == T_LESS) {

   448         TemplateIdAST *ast = new (_pool) TemplateIdAST;

   449         ast->identifier_token = consumeToken();

   450         ast->less_token = consumeToken();

   451         if (LA() == T_GREATER || parseTemplateArgumentList(

   452                 ast->template_argument_list)) {

   453             if (LA() == T_GREATER) {

   454                 ast->greater_token = consumeToken();

   455                 node = ast;

   456                 return true;

   457             }

   458         }

   459     }

   460 

   461     rewind(start);

   462 

   463     return false;

   464 }

   465 

   466 bool Parser::parseNestedNameSpecifier(NestedNameSpecifierListAST *&node,

   467                                       bool /*acceptTemplateId*/)

   468 {

   469     DEBUG_THIS_RULE();

   470     NestedNameSpecifierListAST **nested_name_specifier = &node;

   471     NameAST *class_or_namespace_name = 0;

   472     if (parseClassOrNamespaceName(class_or_namespace_name) && LA() == T_COLON_COLON) {

   473         unsigned scope_token = consumeToken();

   474 

   475         NestedNameSpecifierAST *name = new (_pool) NestedNameSpecifierAST;

   476         name->class_or_namespace_name = class_or_namespace_name;

   477         name->scope_token = scope_token;

   478 

   479         *nested_name_specifier = new (_pool) NestedNameSpecifierListAST(name);

   480         nested_name_specifier = &(*nested_name_specifier)->next;

   481 

   482         while (parseClassOrNamespaceName(class_or_namespace_name) && LA() == T_COLON_COLON) {

   483             scope_token = consumeToken();

   484 

   485             name = new (_pool) NestedNameSpecifierAST;

   486             name->class_or_namespace_name = class_or_namespace_name;

   487             name->scope_token = scope_token;

   488 

   489             *nested_name_specifier = new (_pool) NestedNameSpecifierListAST(name);

   490             nested_name_specifier = &(*nested_name_specifier)->next;

   491         }

   492 

   493         // ### ugly hack

   494         rewind(scope_token);

   495         consumeToken();

   496         return true;

   497     }

   498 

   499     return false;

   500 }

   501 

   502 bool Parser::parseNestedNameSpecifierOpt(NestedNameSpecifierListAST *&name, bool acceptTemplateId)

   503 {

   504     DEBUG_THIS_RULE();

   505     unsigned start = cursor();

   506     if (! parseNestedNameSpecifier(name, acceptTemplateId))

   507         rewind(start);

   508     return true;

   509 }

   510 

   511 bool Parser::parseName(NameAST *&node, bool acceptTemplateId)

   512 {

   513     DEBUG_THIS_RULE();

   514     unsigned global_scope_token = 0;

   515     if (LA() == T_COLON_COLON)

   516         global_scope_token = consumeToken();

   517 

   518     NestedNameSpecifierListAST *nested_name_specifier = 0;

   519     parseNestedNameSpecifierOpt(nested_name_specifier,

   520                                 /*acceptTemplateId=*/ true);

   521 

   522     NameAST *unqualified_name = 0;

   523     if (parseUnqualifiedName(unqualified_name,

   524                              /*acceptTemplateId=*/ acceptTemplateId || nested_name_specifier != 0)) {

   525         if (! global_scope_token && ! nested_name_specifier) {

   526             node = unqualified_name;

   527             return true;

   528         }

   529 

   530         QualifiedNameAST *ast = new (_pool) QualifiedNameAST;

   531         ast->global_scope_token = global_scope_token;

   532         ast->nested_name_specifier_list = nested_name_specifier;

   533         ast->unqualified_name = unqualified_name;

   534         node = ast;

   535         return true;

   536     }

   537 

   538     return false;

   539 }

   540 

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

   542 {

   543     DEBUG_THIS_RULE();

   544     TranslationUnitAST *ast = new (_pool) TranslationUnitAST;

   545     DeclarationListAST **decl = &ast->declaration_list;

   546 

   547     while (LA()) {

   548         unsigned start_declaration = cursor();

   549 

   550         DeclarationAST *declaration = 0;

   551 

   552         if (parseDeclaration(declaration)) {

   553             *decl = new (_pool) DeclarationListAST;

   554             (*decl)->value = declaration;

   555             decl = &(*decl)->next;

   556         } else {

   557             _translationUnit->error(start_declaration, "expected a declaration");

   558             rewind(start_declaration + 1);

   559             skipUntilDeclaration();

   560         }

   561 

   562         _templateArgumentList.clear();

   563     }

   564 

   565     node = ast;

   566     return true;

   567 }

   568 

   569 bool Parser::parseEmptyDeclaration(DeclarationAST *&node)

   570 {

   571     DEBUG_THIS_RULE();

   572     if (LA() == T_SEMICOLON) {

   573         EmptyDeclarationAST *ast = new (_pool) EmptyDeclarationAST;

   574         ast->semicolon_token = consumeToken();

   575         node = ast;

   576         return true;

   577     }

   578     return false;

   579 }

   580 

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

   582 {

   583     DEBUG_THIS_RULE();

   584     switch (LA()) {

   585     case T_SEMICOLON:

   586         return parseEmptyDeclaration(node);

   587 

   588     case T_NAMESPACE:

   589         return parseNamespace(node);

   590 

   591     case T_USING:

   592         return parseUsing(node);

   593 

   594     case T_ASM:

   595         return parseAsmDefinition(node);

   596 

   597     case T_TEMPLATE:

   598     case T_EXPORT:

   599         return parseTemplateDeclaration(node);

   600 

   601     // ObjcC++

   602     case T_AT_CLASS:

   603         return parseObjCClassForwardDeclaration(node);

   604 

   605     case T_AT_INTERFACE:

   606         return parseObjCInterface(node);

   607 

   608     case T_AT_PROTOCOL:

   609         return parseObjCProtocol(node);

   610 

   611     case T_AT_IMPLEMENTATION:

   612         return parseObjCImplementation(node);

   613 

   614     case T_AT_END:

   615         // TODO: should this be done here, or higher-up?

   616         _translationUnit->error(cursor(), "skip stray token `%s'", tok().spell());

   617         consumeToken();

   618         break;

   619 

   620     default: {

   621         if (_objCEnabled && LA() == T___ATTRIBUTE__) {

   622             const unsigned start = cursor();

   623             SpecifierListAST *attributes = 0, **attr = &attributes;

   624             while (parseAttributeSpecifier(*attr))

   625                 attr = &(*attr)->next;

   626             if (LA() == T_AT_INTERFACE)

   627                 return parseObjCInterface(node, attributes);

   628             else if (LA() == T_AT_PROTOCOL)

   629                 return parseObjCProtocol(node, attributes);

   630             else if (LA() == T_AT_PROPERTY)

   631                 return parseObjCPropertyDeclaration(node, attributes);

   632             rewind(start);

   633         }

   634 

   635         if (LA() == T_EXTERN && LA(2) == T_TEMPLATE)

   636             return parseTemplateDeclaration(node);

   637         else if (LA() == T_EXTERN && LA(2) == T_STRING_LITERAL)

   638             return parseLinkageSpecification(node);

   639         else

   640             return parseSimpleDeclaration(node);

   641     }   break; // default

   642 

   643     } // end switch

   644 

   645     return false;

   646 }

   647 

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

   649 {

   650     DEBUG_THIS_RULE();

   651     if (LA() == T_EXTERN && LA(2) == T_STRING_LITERAL) {

   652         LinkageSpecificationAST *ast = new (_pool) LinkageSpecificationAST;

   653         ast->extern_token = consumeToken();

   654         ast->extern_type_token = consumeToken();

   655 

   656         if (LA() == T_LBRACE)

   657             parseLinkageBody(ast->declaration);

   658         else

   659             parseDeclaration(ast->declaration);

   660 

   661         node = ast;

   662         return true;

   663     }

   664 

   665     return false;

   666 }

   667 

   668 bool Parser::parseLinkageBody(DeclarationAST *&node)

   669 {

   670     DEBUG_THIS_RULE();

   671     if (LA() == T_LBRACE) {

   672         LinkageBodyAST *ast = new (_pool) LinkageBodyAST;

   673         ast->lbrace_token = consumeToken();

   674         DeclarationListAST **declaration_ptr = &ast->declaration_list;

   675 

   676         while (int tk = LA()) {

   677             if (tk == T_RBRACE)

   678                 break;

   679 

   680             unsigned start_declaration = cursor();

   681             DeclarationAST *declaration = 0;

   682             if (parseDeclaration(declaration)) {

   683                 *declaration_ptr = new (_pool) DeclarationListAST;

   684                 (*declaration_ptr)->value = declaration;

   685                 declaration_ptr = &(*declaration_ptr)->next;

   686             } else {

   687                 _translationUnit->error(start_declaration, "expected a declaration");

   688                 rewind(start_declaration + 1);

   689                 skipUntilDeclaration();

   690             }

   691 

   692             _templateArgumentList.clear();

   693         }

   694         match(T_RBRACE, &ast->rbrace_token);

   695         node = ast;

   696         return true;

   697     }

   698     return false;

   699 }

   700 

   701 // ### rename parseNamespaceAliarOrDeclaration?

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

   703 {

   704     DEBUG_THIS_RULE();

   705     if (LA() != T_NAMESPACE)

   706         return false;

   707 

   708     unsigned namespace_token = consumeToken();

   709 

   710     if (LA() == T_IDENTIFIER && LA(2) == T_EQUAL) {

   711         NamespaceAliasDefinitionAST *ast =

   712                 new (_pool) NamespaceAliasDefinitionAST;

   713         ast->namespace_token = namespace_token;

   714         ast->namespace_name_token = consumeToken();

   715         ast->equal_token = consumeToken();

   716         parseName(ast->name);

   717         match(T_SEMICOLON, &ast->semicolon_token);

   718         node = ast;

   719         return true;

   720     }

   721 

   722     NamespaceAST *ast = new (_pool) NamespaceAST;

   723     ast->namespace_token = namespace_token;

   724     if (LA() == T_IDENTIFIER)

   725         ast->identifier_token = consumeToken();

   726     SpecifierListAST **attr_ptr = &ast->attribute_list;

   727     while (LA() == T___ATTRIBUTE__) {

   728         parseAttributeSpecifier(*attr_ptr);

   729         attr_ptr = &(*attr_ptr)->next;

   730     }

   731     if (LA() == T_LBRACE)

   732         parseLinkageBody(ast->linkage_body);

   733     node = ast;

   734     return true;

   735 }

   736 

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

   738 {

   739     DEBUG_THIS_RULE();

   740     if (LA() != T_USING)

   741         return false;

   742 

   743     if (LA(2) == T_NAMESPACE)

   744         return parseUsingDirective(node);

   745 

   746     UsingAST *ast = new (_pool) UsingAST;

   747     ast->using_token = consumeToken();

   748 

   749     if (LA() == T_TYPENAME)

   750         ast->typename_token = consumeToken();

   751 

   752     parseName(ast->name);

   753     match(T_SEMICOLON, &ast->semicolon_token);

   754     node = ast;

   755     return true;

   756 }

   757 

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

   759 {

   760     DEBUG_THIS_RULE();

   761     if (LA() == T_USING && LA(2) == T_NAMESPACE) {

   762         UsingDirectiveAST *ast = new (_pool) UsingDirectiveAST;

   763         ast->using_token = consumeToken();

   764         ast->namespace_token = consumeToken();

   765         if (! parseName(ast->name))

   766             _translationUnit->warning(cursor(), "expected `namespace name' before `%s'",

   767                                       tok().spell());

   768         match(T_SEMICOLON, &ast->semicolon_token);

   769         node = ast;

   770         return true;

   771     }

   772     return false;

   773 }

   774 

   775 bool Parser::parseConversionFunctionId(NameAST *&node)

   776 {

   777     DEBUG_THIS_RULE();

   778     if (LA() != T_OPERATOR)

   779         return false;

   780     unsigned operator_token = consumeToken();

   781     SpecifierListAST *type_specifier = 0;

   782     if (! parseTypeSpecifier(type_specifier)) {

   783         return false;

   784     }

   785     PtrOperatorListAST *ptr_operators = 0, **ptr_operators_tail = &ptr_operators;

   786     while (parsePtrOperator(*ptr_operators_tail))

   787         ptr_operators_tail = &(*ptr_operators_tail)->next;

   788 

   789     ConversionFunctionIdAST *ast = new (_pool) ConversionFunctionIdAST;

   790     ast->operator_token = operator_token;

   791     ast->type_specifier_list = type_specifier;

   792     ast->ptr_operator_list = ptr_operators;

   793     node = ast;

   794     return true;

   795 }

   796 

   797 bool Parser::parseOperatorFunctionId(NameAST *&node)

   798 {

   799     DEBUG_THIS_RULE();

   800     if (LA() != T_OPERATOR)

   801         return false;

   802     unsigned operator_token = consumeToken();

   803 

   804     OperatorAST *op = 0;

   805     if (! parseOperator(op))

   806         return false;

   807 

   808     OperatorFunctionIdAST *ast = new (_pool) OperatorFunctionIdAST;

   809     ast->operator_token = operator_token;

   810     ast->op = op;

   811     node = ast;

   812     return true;

   813 }

   814 

   815 Parser::TemplateArgumentListEntry *Parser::templateArgumentListEntry(unsigned tokenIndex)

   816 {

   817     std::map<unsigned, TemplateArgumentListEntry>::iterator it =_templateArgumentList.find(tokenIndex);

   818     if (it != _templateArgumentList.end())

   819         return &it->second;

   820 

   821     return 0;

   822 }

   823 

   824 bool Parser::parseTemplateArgumentList(TemplateArgumentListAST *&node)

   825 {

   826     if (TemplateArgumentListEntry *entry = templateArgumentListEntry(cursor())) {

   827         rewind(entry->cursor);

   828         node = entry->ast;

   829         return entry->ast != 0;

   830     }

   831 

   832     unsigned start = cursor();

   833 

   834     DEBUG_THIS_RULE();

   835     TemplateArgumentListAST **template_argument_ptr = &node;

   836     ExpressionAST *template_argument = 0;

   837     if (parseTemplateArgument(template_argument)) {

   838         *template_argument_ptr = new (_pool) TemplateArgumentListAST;

   839         (*template_argument_ptr)->value = template_argument;

   840         template_argument_ptr = &(*template_argument_ptr)->next;

   841         while (LA() == T_COMMA) {

   842             consumeToken(); // consume T_COMMA

   843 

   844             if (parseTemplateArgument(template_argument)) {

   845                 *template_argument_ptr = new (_pool) TemplateArgumentListAST;

   846                 (*template_argument_ptr)->value = template_argument;

   847                 template_argument_ptr = &(*template_argument_ptr)->next;

   848             }

   849         }

   850 

   851         _templateArgumentList.insert(std::make_pair(cursor(), TemplateArgumentListEntry(start, cursor(), node)));

   852         return true;

   853     }

   854 

   855     _templateArgumentList.insert(std::make_pair(cursor(), TemplateArgumentListEntry(start, cursor(), 0)));

   856 

   857     return false;

   858 }

   859 

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

   861 {

   862     DEBUG_THIS_RULE();

   863     if (LA() != T_ASM)

   864         return false;

   865 

   866     AsmDefinitionAST *ast = new (_pool) AsmDefinitionAST;

   867     ast->asm_token = consumeToken();

   868 

   869     if (LA() == T_VOLATILE)

   870         ast->volatile_token = consumeToken();

   871 

   872     match(T_LPAREN, &ast->lparen_token);

   873     unsigned string_literal_token = 0;

   874     match(T_STRING_LITERAL, &string_literal_token);

   875     while (LA() == T_STRING_LITERAL) {

   876         consumeToken();

   877     }

   878     if (LA() == T_COLON) {

   879         consumeToken(); // skip T_COLON

   880         parseAsmOperandList();

   881         if (LA() == T_COLON) {

   882             consumeToken();

   883             parseAsmOperandList();

   884             if (LA() == T_COLON) {

   885                 consumeToken();

   886                 parseAsmClobberList();

   887             }

   888         } else if (LA() == T_COLON_COLON) {

   889             consumeToken();

   890             parseAsmClobberList();

   891         }

   892     } else if (LA() == T_COLON_COLON) {

   893         consumeToken();

   894         parseAsmClobberList();

   895     }

   896     match(T_RPAREN, &ast->rparen_token);

   897     match(T_SEMICOLON, &ast->semicolon_token);

   898     node = ast;

   899     return true;

   900 }

   901 

   902 bool Parser::parseAsmOperandList()

   903 {

   904     DEBUG_THIS_RULE();

   905     if (LA() != T_STRING_LITERAL)

   906         return true;

   907 

   908     if (parseAsmOperand()) {

   909         while (LA() == T_COMMA) {

   910             consumeToken();

   911             parseAsmOperand();

   912         }

   913         return true;

   914     }

   915 

   916     return false;

   917 }

   918 

   919 bool Parser::parseAsmOperand()

   920 {

   921     DEBUG_THIS_RULE();

   922     unsigned string_literal_token = 0;

   923     match(T_STRING_LITERAL, &string_literal_token);

   924 

   925     if (LA() == T_LBRACKET) {

   926         /*unsigned lbracket_token = */ consumeToken();

   927         match(T_STRING_LITERAL, &string_literal_token);

   928         unsigned rbracket_token = 0;

   929         match(T_RBRACKET, &rbracket_token);

   930     }

   931 

   932     unsigned lparen_token = 0, rparen_token = 0;

   933     match(T_LPAREN, &lparen_token);

   934     ExpressionAST *expression = 0;

   935     parseExpression(expression);

   936     match(T_RPAREN, &rparen_token);

   937     return true;

   938 }

   939 

   940 bool Parser::parseAsmClobberList()

   941 {

   942     DEBUG_THIS_RULE();

   943     if (LA() != T_STRING_LITERAL)

   944         return false;

   945 

   946     unsigned string_literal_token = consumeToken();

   947 

   948     while (LA() == T_COMMA) {

   949         consumeToken();

   950         match(T_STRING_LITERAL, &string_literal_token);

   951     }

   952 

   953     return true;

   954 }

   955 

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

   957 {

   958     DEBUG_THIS_RULE();

   959     if (! (LA(1) == T_TEMPLATE || ((LA(1) == T_EXPORT || LA(1) == T_EXTERN)

   960             && LA(2) == T_TEMPLATE)))

   961         return false;

   962 

   963     TemplateDeclarationAST *ast = new (_pool) TemplateDeclarationAST;

   964 

   965     if (LA() == T_EXPORT || LA() == T_EXPORT)

   966         ast->export_token = consumeToken();

   967 

   968     ast->template_token = consumeToken();

   969 

   970     if (LA() == T_LESS) {

   971         ast->less_token = consumeToken();

   972         if (LA() == T_GREATER || parseTemplateParameterList(ast->template_parameter_list))

   973             match(T_GREATER, &ast->greater_token);

   974     }

   975 

   976     parseDeclaration(ast->declaration);

   977     node = ast;

   978     return true;

   979 }

   980 

   981 bool Parser::parseOperator(OperatorAST *&node) // ### FIXME

   982 {

   983     DEBUG_THIS_RULE();

   984     OperatorAST *ast = new (_pool) OperatorAST;

   985 

   986     switch (LA()) {

   987     case T_NEW:

   988     case T_DELETE: {

   989         ast->op_token = consumeToken();

   990         if (LA() == T_LBRACKET) {

   991             ast->open_token = consumeToken();

   992             match(T_RBRACKET, &ast->close_token);

   993         }

   994     } break;

   995 

   996     case T_PLUS:

   997     case T_MINUS:

   998     case T_STAR:

   999     case T_SLASH:

  1000     case T_PERCENT:

  1001     case T_CARET:

  1002     case T_AMPER:

  1003     case T_PIPE:

  1004     case T_TILDE:

  1005     case T_EXCLAIM:

  1006     case T_LESS:

  1007     case T_GREATER:

  1008     case T_COMMA:

  1009     case T_AMPER_EQUAL:

  1010     case T_CARET_EQUAL:

  1011     case T_SLASH_EQUAL:

  1012     case T_EQUAL:

  1013     case T_EQUAL_EQUAL:

  1014     case T_EXCLAIM_EQUAL:

  1015     case T_GREATER_EQUAL:

  1016     case T_GREATER_GREATER_EQUAL:

  1017     case T_LESS_EQUAL:

  1018     case T_LESS_LESS_EQUAL:

  1019     case T_MINUS_EQUAL:

  1020     case T_PERCENT_EQUAL:

  1021     case T_PIPE_EQUAL:

  1022     case T_PLUS_EQUAL:

  1023     case T_STAR_EQUAL:

  1024     case T_TILDE_EQUAL:

  1025     case T_LESS_LESS:

  1026     case T_GREATER_GREATER:

  1027     case T_AMPER_AMPER:

  1028     case T_PIPE_PIPE:

  1029     case T_PLUS_PLUS:

  1030     case T_MINUS_MINUS:

  1031     case T_ARROW_STAR:

  1032     case T_DOT_STAR:

  1033     case T_ARROW:

  1034         ast->op_token = consumeToken();

  1035         break;

  1036 

  1037     default:

  1038         if (LA() == T_LPAREN && LA(2) == T_RPAREN) {

  1039             ast->op_token = ast->open_token = consumeToken();

  1040             ast->close_token = consumeToken();

  1041         } else if (LA() == T_LBRACKET && LA(2) == T_RBRACKET) {

  1042             ast->op_token = ast->open_token = consumeToken();

  1043             ast->close_token = consumeToken();

  1044         } else {

  1045             return false;

  1046         }

  1047     }

  1048 

  1049     node = ast;

  1050     return true;

  1051 }

  1052 

  1053 bool Parser::parseCvQualifiers(SpecifierListAST *&node)

  1054 {

  1055     DEBUG_THIS_RULE();

  1056 

  1057     unsigned start = cursor();

  1058 

  1059     SpecifierListAST **ast = &node;

  1060     while (*ast)

  1061         ast = &(*ast)->next;

  1062 

  1063     while (int tk = LA()) {

  1064         if (tk == T_CONST || tk == T_VOLATILE) {

  1065             SimpleSpecifierAST *spec = new (_pool) SimpleSpecifierAST;

  1066             spec->specifier_token = consumeToken();

  1067             *ast = new (_pool) SpecifierListAST(spec);

  1068             ast = &(*ast)->next;

  1069         } else if(LA() == T___ATTRIBUTE__) {

  1070             parseAttributeSpecifier(*ast);

  1071             ast = &(*ast)->next;

  1072         } else {

  1073             break;

  1074         }

  1075     }

  1076 

  1077     return start != cursor();

  1078 }

  1079 

  1080 bool Parser::parsePtrOperator(PtrOperatorListAST *&node)

  1081 {

  1082     DEBUG_THIS_RULE();

  1083     if (LA() == T_AMPER) {

  1084         ReferenceAST *ast = new (_pool) ReferenceAST;

  1085         ast->amp_token = consumeToken();

  1086         node = new (_pool) PtrOperatorListAST(ast);

  1087         return true;

  1088     } else if (LA() == T_STAR) {

  1089         PointerAST *ast = new (_pool) PointerAST;

  1090         ast->star_token = consumeToken();

  1091         parseCvQualifiers(ast->cv_qualifier_list);

  1092         node = new (_pool) PtrOperatorListAST(ast);

  1093         return true;

  1094     } else if (LA() == T_COLON_COLON || LA() == T_IDENTIFIER) {

  1095         unsigned scope_or_identifier_token = cursor();

  1096 

  1097         unsigned global_scope_token = 0;

  1098         if (LA() == T_COLON_COLON)

  1099             global_scope_token = consumeToken();

  1100 

  1101         NestedNameSpecifierListAST *nested_name_specifiers = 0;

  1102         bool has_nested_name_specifier = parseNestedNameSpecifier(nested_name_specifiers, true);

  1103         if (has_nested_name_specifier && LA() == T_STAR) {

  1104             PointerToMemberAST *ast = new (_pool) PointerToMemberAST;

  1105             ast->global_scope_token = global_scope_token;

  1106             ast->nested_name_specifier_list = nested_name_specifiers;

  1107             ast->star_token = consumeToken();

  1108             parseCvQualifiers(ast->cv_qualifier_list);

  1109             node = new (_pool) PtrOperatorListAST(ast);

  1110             return true;

  1111         }

  1112         rewind(scope_or_identifier_token);

  1113     }

  1114     return false;

  1115 }

  1116 

  1117 bool Parser::parseTemplateArgument(ExpressionAST *&node)

  1118 {

  1119     DEBUG_THIS_RULE();

  1120     unsigned start = cursor();

  1121     if (parseTypeId(node) && (LA() == T_COMMA || LA() == T_GREATER))

  1122         return true;

  1123 

  1124     rewind(start);

  1125     bool previousTemplateArguments = switchTemplateArguments(true);

  1126     bool parsed = parseLogicalOrExpression(node);

  1127     (void) switchTemplateArguments(previousTemplateArguments);

  1128     return parsed;

  1129 }

  1130 

  1131 bool Parser::parseDeclSpecifierSeq(SpecifierListAST *&decl_specifier_seq,

  1132                                    bool onlyTypeSpecifiers,

  1133                                    bool simplified)

  1134 {

  1135     DEBUG_THIS_RULE();