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 #ifndef AST_H

    44 #define AST_H

    45 

    46 #include "smallobject.h"

    47 #include "list.h"

    48 

    49 QT_BEGIN_NAMESPACE

    50 

    51 class AST;

    52 class NameAST;

    53 class TypeIdAST;

    54 class TypeSpecifierAST;

    55 class DeclaratorAST;

    56 

    57 class Symbol;

    58 class Scope;

    59 

    60 enum NodeType

    61 {

    62     NodeType_Generic = 0,

    63 

    64     NodeType_TemplateArgumentList = 1000,

    65     NodeType_ClassOrNamespaceName,

    66     NodeType_Name,

    67     NodeType_Declaration,

    68     NodeType_TypeSpecifier,

    69     NodeType_BaseSpecifier,

    70     NodeType_BaseClause,

    71     NodeType_ClassSpecifier,

    72     NodeType_Enumerator,

    73     NodeType_EnumSpecifier,

    74     NodeType_ElaboratedTypeSpecifier,

    75     NodeType_LinkageBody,

    76     NodeType_LinkageSpecification,

    77     NodeType_Namespace,

    78     NodeType_NamespaceAlias,

    79     NodeType_Using,

    80     NodeType_UsingDirective,

    81     NodeType_InitDeclaratorList,

    82     NodeType_Typedef,

    83     NodeType_Declarator,

    84     NodeType_InitDeclarator,

    85     NodeType_TemplateDeclaration,

    86     NodeType_SimpleDeclaration,

    87     NodeType_Statement,

    88     NodeType_StatementList,

    89     NodeType_IfStatement,

    90     NodeType_WhileStatement,

    91     NodeType_DoStatement,

    92     NodeType_ForStatement,

    93     NodeType_SwitchStatement,

    94     NodeType_DeclarationStatement,

    95     NodeType_LabeledStatement,

    96     NodeType_ReturnStatement,

    97     NodeType_TranslationUnit,

    98     NodeType_FunctionDefinition,

    99     NodeType_ExpressionStatement,

   100     NodeType_ParameterDeclaration,

   101     NodeType_ParameterDeclarationList,

   102     NodeType_ParameterDeclarationClause,

   103     NodeType_AccessDeclaration,

   104     NodeType_TypeParameter,

   105     NodeType_TemplateParameter,

   106     NodeType_TemplateParameterList,

   107     NodeType_Condition,

   108 

   109     NodeType_TypeId,

   110 

   111     NodeType_Expression = 2000,

   112     NodeType_BinaryExpression,

   113     NodeType_PrimaryExpression,

   114 

   115 //

   116 // postfix expression

   117 //

   118     NodeType_PostfixExpression,

   119     NodeType_Subscripting,

   120     NodeType_FunctionCall,

   121     NodeType_ExplicitTypeConversion,

   122     NodeType_PseudoConstructorCall,

   123     NodeType_ClassMemberAccess,

   124     NodeType_IncrDecr,

   125     NodeType_CppCastExpression,

   126     NodeType_TypeIdentification,

   127 

   128     NodeType_UnaryExpression,

   129     NodeType_NewExpression,

   130     NodeType_NewTypeId,

   131     NodeType_NewDeclarator,

   132     NodeType_NewInitializer,

   133     NodeType_DeleteExpression,

   134     NodeType_CastExpression,

   135     NodeType_ConditionalExpression,

   136     NodeType_ThrowExpression,

   137 

   138     NodeType_Custom = 3000

   139 };

   140 

   141 

   142 template <typename T>

   143 inline int length(List<T> *e)

   144 {

   145     return e ? e->size() : 0;

   146 }

   147 

   148 class AST

   149 {

   150 public:

   151     enum { Type=NodeType_Generic };

   152 

   153     pool *_pool;

   154 

   155     static int N;

   156 

   157 public:

   158     AST(int startToken=0, int count=1);

   159     virtual ~AST() { --N; }

   160 

   161     inline int startToken() const

   162     { return m_startToken; }

   163 

   164     inline int endToken() const

   165     { return m_endToken; }

   166 

   167     inline void setPosition(int startToken, int endToken)

   168     {

   169         m_startToken = startToken;

   170         m_endToken = endToken;

   171     }

   172 

   173     inline int nodeType() const

   174     { return m_nodeType; }

   175 

   176     inline void setNodeType(int nodeType)

   177     { m_nodeType = nodeType; }

   178 

   179     inline AST *parent() const

   180     { return m_parent; }

   181 

   182     void setParent(AST *parent);

   183 

   184     inline List<AST *> *children() const

   185     { return m_children; }

   186 

   187     void appendChild(AST *child);

   188     void removeChild(AST *child);

   189 

   190 // ### move

   191     inline Scope *scope() const

   192     {

   193         if (m_scope)

   194             return m_scope;

   195 

   196         return m_parent ? m_parent->scope() : 0;

   197     }

   198 

   199     inline void setScope(Scope *scope)

   200     { m_scope = scope; }

   201 

   202 private:

   203     Scope *m_scope;

   204     int m_nodeType;

   205     int m_startToken;

   206     int m_endToken;

   207     AST *m_parent;

   208     List<AST *> *m_children;

   209 

   210 private:

   211     AST(const AST &source);

   212     void operator = (const AST &source);

   213 };

   214 

   215 class AbstractExpressionAST: public AST

   216 {

   217 public:

   218     enum { Type = NodeType_Expression };

   219 

   220     AbstractExpressionAST();

   221 

   222     inline Symbol *symbol() const

   223     { return m_symbol; }

   224 

   225     inline void setSymbol(Symbol *symbol)

   226     { m_symbol = symbol; }

   227 

   228 private:

   229     Symbol *m_symbol;

   230 };

   231 

   232 // ### remove me

   233 template <int kind, class Base = AbstractExpressionAST>

   234 class ExpressionAST: public Base

   235 {

   236 public:

   237     enum { Type = kind };

   238 

   239 public:

   240     inline ExpressionAST() {}

   241 

   242 private:

   243     ExpressionAST(const ExpressionAST &source);

   244     void operator = (const ExpressionAST &source);

   245 };

   246 

   247 class BinaryExpressionAST: public AbstractExpressionAST

   248 {

   249 public:

   250     enum { Type = NodeType_BinaryExpression };

   251 

   252 public:

   253     BinaryExpressionAST();

   254 

   255     inline AST *op() const

   256     { return m_op; }

   257 

   258     inline AbstractExpressionAST *leftExpression() const

   259     { return m_left; }

   260 

   261     inline AbstractExpressionAST *rightExpression() const

   262     { return m_right; }

   263 

   264     void setOp(AST *op);

   265     void setLeftExpression(AbstractExpressionAST *left);

   266     void setRightExpression(AbstractExpressionAST *right);

   267 

   268 private:

   269     AST *m_op;

   270     AbstractExpressionAST *m_left;

   271     AbstractExpressionAST *m_right;

   272 

   273 private:

   274     BinaryExpressionAST(const BinaryExpressionAST &source);

   275     void operator = (const BinaryExpressionAST &source);

   276 };

   277 

   278 class ConditionalExpressionAST: public AbstractExpressionAST

   279 {

   280 public:

   281     enum { Type = NodeType_ConditionalExpression };

   282 

   283 public:

   284     ConditionalExpressionAST();

   285 

   286     inline AbstractExpressionAST *condition() const

   287     { return m_condition; }

   288 

   289     inline AbstractExpressionAST *leftExpression() const

   290     { return m_left; }

   291 

   292     inline AbstractExpressionAST *rightExpression() const

   293     { return m_right; }

   294 

   295     void setCondition(AbstractExpressionAST *condition);

   296     void setLeftExpression(AbstractExpressionAST *left);

   297     void setRightExpression(AbstractExpressionAST *right);

   298 

   299 private:

   300     AbstractExpressionAST *m_condition;

   301     AbstractExpressionAST *m_left;

   302     AbstractExpressionAST *m_right;

   303 

   304 private:

   305     ConditionalExpressionAST(const ConditionalExpressionAST& source);

   306     void operator = (const ConditionalExpressionAST &source);

   307 };

   308 

   309 

   310 //

   311 // postfix expression

   312 //

   313 

   314 class SubscriptingAST: public AbstractExpressionAST

   315 {

   316 public:

   317     enum { Type = NodeType_Subscripting };

   318 

   319 public:

   320     SubscriptingAST();

   321 

   322     inline AbstractExpressionAST *expression() const

   323     { return m_expression; }

   324 

   325     inline AbstractExpressionAST *subscript() const

   326     { return m_subscript; }

   327 

   328     void setExpression(AbstractExpressionAST *expression);

   329     void setSubscript(AbstractExpressionAST *subscript);

   330 

   331 private:

   332     AbstractExpressionAST *m_expression;

   333     AbstractExpressionAST *m_subscript;

   334 

   335 private:

   336     SubscriptingAST(const SubscriptingAST &source);

   337     void operator = (const SubscriptingAST &source);

   338 };

   339 

   340 class FunctionCallAST: public AbstractExpressionAST

   341 {

   342 public:

   343     enum { Type = NodeType_FunctionCall };

   344 

   345 public:

   346     FunctionCallAST();

   347 

   348     inline AbstractExpressionAST *expression() const

   349     { return m_expression; }

   350 

   351     inline AbstractExpressionAST *arguments() const

   352     { return m_arguments; }

   353 

   354     void setExpression(AbstractExpressionAST *expression);

   355     void setArguments(AbstractExpressionAST *arguments);

   356 

   357 private:

   358     AbstractExpressionAST *m_expression;

   359     AbstractExpressionAST *m_arguments;

   360 

   361 private:

   362     FunctionCallAST(const FunctionCallAST &source);

   363     void operator = (const FunctionCallAST &source);

   364 };

   365 

   366 class ExplicitTypeConversionAST: public AbstractExpressionAST

   367 {

   368 public:

   369     enum { Type = NodeType_ExplicitTypeConversion };

   370 

   371 public:

   372     ExplicitTypeConversionAST();

   373 

   374 private:

   375     ExplicitTypeConversionAST(const ExplicitTypeConversionAST &source);

   376     void operator = (const ExplicitTypeConversionAST &source);

   377 };

   378 

   379 class PseudoDestructorCallAST: public AbstractExpressionAST

   380 {

   381 public:

   382     enum { Type = NodeType_PseudoConstructorCall };

   383 

   384 public:

   385     PseudoDestructorCallAST();

   386 

   387 private:

   388     PseudoDestructorCallAST(const PseudoDestructorCallAST &source);

   389     void operator = (const PseudoDestructorCallAST &source);

   390 };

   391 

   392 class ClassMemberAccessAST: public AbstractExpressionAST

   393 {

   394 public:

   395     enum { Type = NodeType_ClassMemberAccess };

   396 

   397 public:

   398     ClassMemberAccessAST();

   399 

   400     inline AST *op() const

   401     { return m_op; }

   402 

   403     inline AbstractExpressionAST *expression() const

   404     { return m_expression; }

   405 

   406     inline NameAST *name() const

   407     { return m_name; }

   408 

   409     void setOp(AST *op);

   410     void setExpression(AbstractExpressionAST *expression);

   411     void setName(NameAST *name);

   412 

   413 private:

   414     AST *m_op;

   415     AbstractExpressionAST *m_expression;

   416     AST *m_templ;

   417     NameAST *m_name;

   418 

   419 private:

   420     ClassMemberAccessAST(const ClassMemberAccessAST &source);

   421     void operator = (const ClassMemberAccessAST &source);

   422 };

   423 

   424 class IncrDecrAST: public AbstractExpressionAST

   425 {

   426 public:

   427     enum { Type = NodeType_IncrDecr };

   428 

   429 public:

   430     IncrDecrAST();

   431 

   432     inline AST *op() const

   433     { return m_op; }

   434 

   435     inline AbstractExpressionAST *expression() const

   436     { return m_expression; }

   437 

   438     void setOp(AST *op);

   439     void setExpression(AbstractExpressionAST *expression);

   440 

   441 private:

   442     AST *m_op;

   443     AbstractExpressionAST *m_expression;

   444 

   445 private:

   446     IncrDecrAST(const IncrDecrAST &source);

   447     void operator = (const IncrDecrAST &source);

   448 };

   449 

   450 class CppCastExpressionAST: public AbstractExpressionAST

   451 {

   452 public:

   453     enum { Type = NodeType_CppCastExpression };

   454 

   455 public:

   456     CppCastExpressionAST();

   457 

   458     inline AST *castOp() const

   459     { return m_castOp; }

   460 

   461     inline AST *typeId() const

   462     { return m_typeId; }

   463 

   464     inline AbstractExpressionAST *expression() const

   465     { return m_expression; }

   466 

   467     void setCastOp(AST *castOp);

   468     void setTypeId(AST *typeId);

   469     void setExpression(AbstractExpressionAST *expression);

   470 

   471 private:

   472     AST *m_castOp;

   473     AST *m_typeId;

   474     AbstractExpressionAST *m_expression;

   475 

   476 private:

   477     CppCastExpressionAST(const CppCastExpressionAST &source);

   478     void operator = (const CppCastExpressionAST &source);

   479 };

   480 

   481 class TypeIdentificationAST: public AbstractExpressionAST

   482 {

   483 public:

   484     enum { Type = NodeType_TypeIdentification };

   485 

   486 public:

   487     TypeIdentificationAST();

   488 

   489 private:

   490     TypeIdentificationAST(const TypeIdentificationAST &source);

   491     void operator = (const TypeIdentificationAST &source);

   492 };

   493 

   494 class TypeIdAST: public AST

   495 {

   496 public:

   497     enum { Type = NodeType_TypeId };

   498 

   499 public:

   500     TypeIdAST();

   501 

   502     inline TypeSpecifierAST *typeSpecifier() const

   503     { return m_typeSpecifier; }

   504 

   505     inline DeclaratorAST *declarator() const

   506     { return m_declarator; }

   507 

   508     void setTypeSpecifier(TypeSpecifierAST *typeSpecifier);

   509     void setDeclarator(DeclaratorAST *declarator);

   510 

   511 private:

   512     TypeSpecifierAST *m_typeSpecifier;

   513     DeclaratorAST *m_declarator;

   514 

   515 private:

   516     TypeIdAST(const TypeIdAST &source);

   517     void operator = (const TypeIdAST &source);

   518 };

   519 

   520 class StatementAST: public AST

   521 {

   522 public:

   523     enum { Type = NodeType_Statement };

   524 };

   525 

   526 class TemplateArgumentListAST: public AST

   527 {

   528 public:

   529     enum { Type = NodeType_TemplateArgumentList };

   530 

   531 public:

   532     TemplateArgumentListAST();

   533 

   534     void addArgument(AST *arg);

   535     inline List<AST *> *argumentList() const { return m_argumentList; }

   536 

   537 private:

   538     List<AST *> *m_argumentList;

   539 

   540 private:

   541     TemplateArgumentListAST(const TemplateArgumentListAST &source);

   542     void operator = (const TemplateArgumentListAST &source);

   543 };

   544 

   545 class ClassOrNamespaceNameAST: public AST

   546 {

   547 public:

   548     enum { Type = NodeType_ClassOrNamespaceName };

   549 

   550 public:

   551     ClassOrNamespaceNameAST();

   552 

   553     inline AST *name() const { return m_name; }

   554     void setName(AST *name);

   555 

   556     inline TemplateArgumentListAST *templateArgumentList() const { return m_templateArgumentList; }

   557     void setTemplateArgumentList(TemplateArgumentListAST *templateArgumentList);

   558 

   559 private:

   560     AST* m_name;

   561     TemplateArgumentListAST* m_templateArgumentList;

   562 

   563 private:

   564     ClassOrNamespaceNameAST(const ClassOrNamespaceNameAST &source);

   565     void operator = (const ClassOrNamespaceNameAST &source);

   566 };

   567 

   568 class NameAST: public AST

   569 {

   570 public:

   571     enum { Type = NodeType_Name };

   572 

   573 public:

   574     NameAST();

   575 

   576     inline bool isGlobal() const { return m_global; }

   577     void setGlobal(bool b);

   578 

   579     void addClassOrNamespaceName(ClassOrNamespaceNameAST *classOrNamespaceName);

   580     inline List<ClassOrNamespaceNameAST *> *classOrNamespaceNameList() const { return m_classOrNamespaceNameList; }

   581 

   582     inline ClassOrNamespaceNameAST *unqualifiedName() const { return m_unqualifiedName; }

   583     void setUnqualifiedName(ClassOrNamespaceNameAST *unqualifiedName);

   584 

   585 private:

   586     bool m_global;

   587     ClassOrNamespaceNameAST* m_unqualifiedName;

   588     List<ClassOrNamespaceNameAST *> *m_classOrNamespaceNameList;

   589 

   590 private:

   591     NameAST(const NameAST &source);

   592     void operator = (const NameAST &source);

   593 };

   594 

   595 class TypeParameterAST: public AST

   596 {

   597 public:

   598     enum { Type = NodeType_TypeParameter };

   599 

   600 public:

   601     TypeParameterAST();

   602 

   603     inline AST *kind() const { return m_kind; }

   604     void setKind(AST *kind);

   605 

   606     inline class TemplateParameterListAST *templateParameterList() const { return m_templateParameterList; }

   607     void setTemplateParameterList(class TemplateParameterListAST *templateParameterList);

   608 

   609     inline NameAST *name() const { return m_name; }

   610     void setName(NameAST *name);

   611 

   612     inline AST *typeId() const { return m_typeId; }

   613     void setTypeId(AST *typeId);

   614 

   615 private:

   616     AST* m_kind;

   617     class TemplateParameterListAST *m_templateParameterList;

   618     NameAST* m_name;

   619     AST* m_typeId;

   620 

   621 private:

   622     TypeParameterAST(const TypeParameterAST &source);

   623     void operator = (const TypeParameterAST &source);

   624 };

   625 

   626 class DeclarationAST: public AST

   627 {

   628 public:

   629     enum { Type = NodeType_Declaration };

   630 

   631 public:

   632     DeclarationAST();

   633 

   634 private:

   635     DeclarationAST(const DeclarationAST &source);

   636     void operator = (const DeclarationAST &source);

   637 };

   638 

   639 class AccessDeclarationAST: public DeclarationAST

   640 {

   641 public:

   642     enum { Type = NodeType_AccessDeclaration };

   643 

   644 public:

   645     AccessDeclarationAST();

   646 

   647     inline List<AST *> *accessList() const { return m_accessList; }

   648     void addAccess(AST *access);

   649 

   650 private:

   651     List<AST *> *m_accessList;

   652 

   653 private:

   654     AccessDeclarationAST(const AccessDeclarationAST &source);

   655     void operator = (const AccessDeclarationAST &source);

   656 };

   657 

   658 class TypeSpecifierAST: public AST

   659 {

   660 public:

   661     enum { Type = NodeType_TypeSpecifier };

   662 

   663 public:

   664     TypeSpecifierAST();

   665 

   666     inline virtual NameAST *name() const { return m_name; }

   667     virtual void setName(NameAST *name);

   668 

   669     inline AST *cvQualify() const { return m_cvQualify; }

   670     void setCvQualify(AST *cvQualify);

   671 

   672     inline AST *cv2Qualify() const { return m_cv2Qualify; }

   673     void setCv2Qualify(AST *cv2Qualify);

   674 

   675 private:

   676     NameAST* m_name;

   677     AST* m_cvQualify;

   678     AST* m_cv2Qualify;

   679 

   680 private:

   681     TypeSpecifierAST(const TypeSpecifierAST &source);

   682     void operator = (const TypeSpecifierAST &source);

   683 };

   684 

   685 class BaseSpecifierAST: public AST

   686 {

   687 public:

   688     enum { Type = NodeType_BaseSpecifier };

   689 

   690 public:

   691     BaseSpecifierAST();

   692 

   693     inline AST *isVirtual() const { return m_isVirtual; }

   694     void setIsVirtual(AST *isVirtual);

   695 

   696     inline AST *access() const { return m_access; }

   697     void setAccess(AST *access);

   698 

   699     inline NameAST *name() const { return m_name; }

   700     void setName(NameAST *name);

   701 

   702 private:

   703     AST* m_isVirtual;

   704     AST* m_access;

   705     NameAST* m_name;

   706 

   707 private:

   708     BaseSpecifierAST(const BaseSpecifierAST &source);

   709     void operator = (const BaseSpecifierAST &source);

   710 };

   711 

   712 class BaseClauseAST: public AST

   713 {

   714 public:

   715     enum { Type = NodeType_BaseClause };

   716 

   717 public:

   718     BaseClauseAST();

   719 

   720     void addBaseSpecifier(BaseSpecifierAST *baseSpecifier);

   721     inline List<BaseSpecifierAST *> *baseSpecifierList() const { return m_baseSpecifierList; }

   722 

   723 private:

   724     List<BaseSpecifierAST *> *m_baseSpecifierList;

   725 

   726 private:

   727     BaseClauseAST(const BaseClauseAST &source);

   728     void operator = (const BaseClauseAST &source);

   729 };

   730 

   731 class ClassSpecifierAST: public TypeSpecifierAST

   732 {

   733 public:

   734     enum { Type = NodeType_ClassSpecifier };

   735 

   736 public:

   737     ClassSpecifierAST();

   738 

   739     inline AST *winDeclSpec() const { return m_winDeclSpec; }

   740     void setWinDeclSpec(AST *winDeclSpec);

   741 

   742     inline AST *classKey() const { return m_classKey; }

   743     void setClassKey(AST *classKey);

   744 

   745     inline BaseClauseAST *baseClause() const { return m_baseClause; }

   746     void setBaseClause(BaseClauseAST *baseClause);

   747 

   748     inline List<DeclarationAST *> *declarationList() const { return m_declarationList; }

   749     void addDeclaration(DeclarationAST *declaration);

   750 

   751 private:

   752     AST* m_winDeclSpec;

   753     AST* m_classKey;

   754     BaseClauseAST* m_baseClause;

   755     List<DeclarationAST *> *m_declarationList;

   756 

   757 private:

   758     ClassSpecifierAST(const ClassSpecifierAST &source);

   759     void operator = (const ClassSpecifierAST &source);

   760 };

   761 

   762 class EnumeratorAST: public AST

   763 {

   764 public:

   765     enum { Type = NodeType_Enumerator };

   766 

   767 public:

   768     EnumeratorAST();

   769 

   770     inline AST *id() const { return m_id; }

   771     void setId(AST *id);

   772 

   773     inline AbstractExpressionAST *expression() const { return m_expression; }

   774     void setExpression(AbstractExpressionAST *expr);

   775 

   776 private:

   777     AST* m_id;

   778     AbstractExpressionAST* m_expression;

   779 

   780 private:

   781     EnumeratorAST(const EnumeratorAST &source);

   782     void operator = (const EnumeratorAST &source);

   783 };

   784 

   785 class EnumSpecifierAST: public TypeSpecifierAST

   786 {

   787 public:

   788     enum { Type = NodeType_EnumSpecifier };

   789 

   790 public:

   791     EnumSpecifierAST();

   792 

   793     void addEnumerator(EnumeratorAST *enumerator);

   794     inline List<EnumeratorAST *> *enumeratorList() const { return m_enumeratorList; }

   795 

   796 private:

   797     List<EnumeratorAST *> *m_enumeratorList;

   798 

   799 private:

   800     EnumSpecifierAST(const EnumSpecifierAST &source);

   801     void operator = (const EnumSpecifierAST &source);

   802 };

   803 

   804 class ElaboratedTypeSpecifierAST: public TypeSpecifierAST

   805 {

   806 public:

   807     enum { Type = NodeType_ElaboratedTypeSpecifier };

   808 

   809 public:

   810     ElaboratedTypeSpecifierAST();

   811 

   812     inline AST *kind() const { return m_kind; }

   813     void setKind(AST *kind);

   814 

   815 private:

   816     AST* m_kind;

   817 

   818 private:

   819     ElaboratedTypeSpecifierAST(const ElaboratedTypeSpecifierAST &source);

   820     void operator = (const ElaboratedTypeSpecifierAST &source);

   821 };

   822 

   823 

   824 class LinkageBodyAST: public AST

   825 {

   826 public:

   827     enum { Type = NodeType_LinkageBody };

   828 

   829 public:

   830     LinkageBodyAST();

   831 

   832     void addDeclaration(DeclarationAST *ast);

   833     inline List<DeclarationAST *> *declarationList() const { return m_declarationList; }

   834 

   835 private:

   836     List<DeclarationAST *> *m_declarationList;

   837 

   838 private:

   839     LinkageBodyAST(const LinkageBodyAST &source);

   840     void operator = (const LinkageBodyAST &source);

   841 };

   842 

   843 class LinkageSpecificationAST: public DeclarationAST

   844 {

   845 public:

   846     enum { Type = NodeType_LinkageSpecification };

   847 

   848 public:

   849     LinkageSpecificationAST();

   850 

   851     inline AST *externType() const { return m_externType; }

   852     void setExternType(AST *externType);

   853 

   854     inline LinkageBodyAST *linkageBody() const { return m_linkageBody; }

   855     void setLinkageBody(LinkageBodyAST *linkageBody);

   856 

   857     inline DeclarationAST *declaration() const { return m_declaration; }

   858     void setDeclaration(DeclarationAST *decl);

   859 

   860 private:

   861     AST* m_externType;

   862     LinkageBodyAST* m_linkageBody;

   863     DeclarationAST* m_declaration;

   864 

   865 private:

   866     LinkageSpecificationAST(const LinkageSpecificationAST &source);

   867     void operator = (const LinkageSpecificationAST &source);

   868 };

   869 

   870 class NamespaceAST: public DeclarationAST

   871 {

   872 public:

   873     enum { Type = NodeType_Namespace };

   874 

   875 public:

   876     NamespaceAST();

   877 

   878     inline AST *namespaceName() const { return m_namespaceName; }

   879     void setNamespaceName(AST *namespaceName);

   880 

   881     inline LinkageBodyAST *linkageBody() const { return m_linkageBody; }

   882     void setLinkageBody(LinkageBodyAST *linkageBody);

   883 

   884 private:

   885     AST* m_namespaceName;

   886     LinkageBodyAST* m_linkageBody;

   887 

   888 private:

   889     NamespaceAST(const NamespaceAST &source);

   890     void operator = (const NamespaceAST &source);

   891 };

   892 

   893 class NamespaceAliasAST: public DeclarationAST

   894 {

   895 public:

   896     enum { Type = NodeType_NamespaceAlias };

   897 

   898 public:

   899     NamespaceAliasAST();

   900 

   901     inline AST *namespaceName() const { return m_namespaceName; }

   902     void setNamespaceName(AST *name);

   903 

   904     inline NameAST *aliasName() const { return m_aliasName; }

   905     void setAliasName(NameAST *name);

   906 

   907 private:

   908     AST* m_namespaceName;

   909     NameAST* m_aliasName;

   910 

   911 private:

   912     NamespaceAliasAST(const NamespaceAliasAST &source);

   913     void operator = (const NamespaceAliasAST &source);

   914 };

   915 

   916 class UsingAST: public DeclarationAST

   917 {

   918 public:

   919     enum { Type = NodeType_Using };

   920 

   921 public:

   922     UsingAST();

   923 

   924     inline AST *typeName() const { return m_typeName; }

   925     void setTypeName(AST *typeName);

   926 

   927     inline NameAST *name() const { return m_name; }

   928     void setName(NameAST *name);

   929 

   930 private:

   931     AST* m_typeName;

   932     NameAST* m_name;

   933 

   934 private:

   935     UsingAST(const UsingAST &source);

   936     void operator = (const UsingAST &source);

   937 };

   938 

   939 class UsingDirectiveAST: public DeclarationAST

   940 {

   941 public:

   942     enum { Type = NodeType_UsingDirective };

   943 

   944 public:

   945     UsingDirectiveAST();

   946 

   947     inline NameAST *name() const { return m_name; }

   948     void setName(NameAST *name);

   949 

   950 private:

   951     NameAST* m_name;

   952 

   953 private:

   954     UsingDirectiveAST(const UsingDirectiveAST &source);

   955     void operator = (const UsingDirectiveAST &source);

   956 };

   957 

   958 class DeclaratorAST: public AST

   959 {

   960 public:

   961     enum { Type = NodeType_Declarator };

   962 

   963 public:

   964     DeclaratorAST();

   965 

   966     inline List<AST *> *ptrOpList() const { return m_ptrOpList; }

   967     void addPtrOp(AST *ptrOp);

   968 

   969     inline DeclaratorAST *subDeclarator() const { return m_subDeclarator; }

   970     void setSubDeclarator(DeclaratorAST *subDeclarator);

   971 

   972     inline NameAST *declaratorId() const { return m_declaratorId; }

   973     void setDeclaratorId(NameAST *declaratorId);

   974 

   975     inline AST *bitfieldInitialization() const { return m_bitfieldInitialization; }

   976     void setBitfieldInitialization(AST *bitfieldInitialization);

   977 

   978     inline List<AST *> *arrayDimensionList() const { return m_arrayDimensionList; }

   979     void addArrayDimension(AST *arrayDimension);

   980 

   981     inline class ParameterDeclarationClauseAST *parameterDeclarationClause() const { return m_parameterDeclarationClause; }

   982     void setParameterDeclarationClause(class ParameterDeclarationClauseAST  *parameterDeclarationClause);

   983 

   984     // ### replace 'constant' with cvQualify

   985     inline AST *constant() const { return m_constant; }

   986     void setConstant(AST *constant);

   987 

   988     inline AST *exceptionSpecification() const { return m_exceptionSpecification; }

   989     void setExceptionSpecification(AST *exceptionSpecification);

   990 

   991 private:

   992     List<AST *> *m_ptrOpList;

   993     DeclaratorAST * m_subDeclarator;

   994     NameAST* m_declaratorId;

   995     AST* m_bitfieldInitialization;

   996     List<AST *> *m_arrayDimensionList;

   997     class ParameterDeclarationClauseAST * m_parameterDeclarationClause;

   998     AST* m_constant;

   999     AST* m_exceptionSpecification;

  1000 

  1001 private:

  1002     DeclaratorAST(const DeclaratorAST &source);

  1003     void operator = (const DeclaratorAST &source);

  1004 };

  1005 

  1006 class ParameterDeclarationAST: public AST

  1007 {

  1008 public:

  1009     enum { Type = NodeType_ParameterDeclaration };

  1010 

  1011 public:

  1012     ParameterDeclarationAST();

  1013 

  1014     inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; }

  1015     void setTypeSpec(TypeSpecifierAST *typeSpec);

  1016 

  1017     inline DeclaratorAST *declarator() const { return m_declarator; }

  1018     void setDeclarator(DeclaratorAST *declarator);

  1019 

  1020     inline AbstractExpressionAST *expression() const { return m_expression; }

  1021     void setExpression(AbstractExpressionAST *expression);

  1022 

  1023 private:

  1024     TypeSpecifierAST* m_typeSpec;

  1025     DeclaratorAST* m_declarator;

  1026     AbstractExpressionAST* m_expression;

  1027 

  1028 private:

  1029     ParameterDeclarationAST(const ParameterDeclarationAST &source);

  1030     void operator = (const ParameterDeclarationAST &source);

  1031 };

  1032 

  1033 class ParameterDeclarationListAST: public AST

  1034 {

  1035 public:

  1036     enum { Type = NodeType_ParameterDeclarationList };

  1037 

  1038 public:

  1039     ParameterDeclarationListAST();

  1040 

  1041     inline List<ParameterDeclarationAST *> *parameterList() const { return m_parameterList; }

  1042     void addParameter(ParameterDeclarationAST *parameter);

  1043 

  1044 private:

  1045     List<ParameterDeclarationAST *> *m_parameterList;

  1046 

  1047 private:

  1048     ParameterDeclarationListAST(const ParameterDeclarationListAST &source);

  1049     void operator = (const ParameterDeclarationListAST &source);

  1050 };

  1051 

  1052 class ParameterDeclarationClauseAST: public AST

  1053 {

  1054 public:

  1055     enum { Type = NodeType_ParameterDeclarationClause };

  1056 

  1057 public:

  1058     ParameterDeclarationClauseAST();

  1059 

  1060     inline ParameterDeclarationListAST *parameterDeclarationList() const { return m_parameterDeclarationList; }

  1061     void setParameterDeclarationList(ParameterDeclarationListAST *parameterDeclarationList);

  1062 

  1063     inline AST *ellipsis() const { return m_ellipsis; }

  1064     void setEllipsis(AST *ellipsis);

  1065 

  1066 private:

  1067     ParameterDeclarationListAST* m_parameterDeclarationList;

  1068     AST* m_ellipsis;

  1069 

  1070 private:

  1071     ParameterDeclarationClauseAST(const ParameterDeclarationClauseAST &source);

  1072     void operator = (const ParameterDeclarationClauseAST &source);

  1073 };

  1074 

  1075 

  1076 class InitDeclaratorAST: public AST

  1077 {

  1078 public:

  1079     enum { Type = NodeType_InitDeclarator };

  1080 

  1081 public:

  1082     InitDeclaratorAST();

  1083 

  1084     inline DeclaratorAST *declarator() const { return m_declarator; }

  1085     void setDeclarator(DeclaratorAST *declarator);

  1086 

  1087     inline AST *initializer() const { return m_initializer; }

  1088     void setInitializer(AST *initializer);

  1089 

  1090 private:

  1091     DeclaratorAST* m_declarator;

  1092     AST* m_initializer;

  1093 

  1094 private:

  1095     InitDeclaratorAST(const InitDeclaratorAST &source);

  1096     void operator = (const InitDeclaratorAST &source);

  1097 };

  1098 

  1099 class InitDeclaratorListAST: public AST

  1100 {

  1101 public:

  1102     enum { Type = NodeType_InitDeclaratorList };

  1103 

  1104 public:

  1105     InitDeclaratorListAST();

  1106 

  1107     inline List<InitDeclaratorAST *> *initDeclaratorList() const { return m_initDeclaratorList; }

  1108     void addInitDeclarator(InitDeclaratorAST *decl);

  1109 

  1110 private:

  1111     List<InitDeclaratorAST *> *m_initDeclaratorList;

  1112 

  1113 private:

  1114     InitDeclaratorListAST(const InitDeclaratorListAST &source);

  1115     void operator = (const InitDeclaratorListAST &source);

  1116 };

  1117 

  1118 class TypedefAST: public DeclarationAST

  1119 {

  1120 public:

  1121     enum { Type = NodeType_Typedef };

  1122 

  1123 public:

  1124     TypedefAST();

  1125 

  1126     inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; }

  1127     void setTypeSpec(TypeSpecifierAST *typeSpec);

  1128 

  1129     inline InitDeclaratorListAST *initDeclaratorList() const { return m_initDeclaratorList; }

  1130     void setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList);

  1131 

  1132 private:

  1133     TypeSpecifierAST* m_typeSpec;

  1134     InitDeclaratorListAST* m_initDeclaratorList;