tools/porting/src/ast.h
changeset 0 1918ee327afb
child 4 3b1da2848fc7
equal deleted inserted replaced
-1:000000000000 0:1918ee327afb
       
     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;
       
  1135 
       
  1136 private:
       
  1137     void operator = (const TypedefAST &source);
       
  1138 };
       
  1139 
       
  1140 class TemplateParameterAST: public AST
       
  1141 {
       
  1142 public:
       
  1143     enum { Type = NodeType_TemplateParameter };
       
  1144 
       
  1145 public:
       
  1146     TemplateParameterAST();
       
  1147 
       
  1148     inline TypeParameterAST *typeParameter() const { return m_typeParameter; }
       
  1149     void setTypeParameter(TypeParameterAST *typeParameter);
       
  1150 
       
  1151     inline ParameterDeclarationAST *typeValueParameter() const { return m_typeValueParameter; }
       
  1152     void setTypeValueParameter(ParameterDeclarationAST *typeValueParameter);
       
  1153 
       
  1154 private:
       
  1155     TypeParameterAST* m_typeParameter;
       
  1156     ParameterDeclarationAST* m_typeValueParameter;
       
  1157 
       
  1158 private:
       
  1159     TemplateParameterAST(const TemplateParameterAST &source);
       
  1160     void operator = (const TemplateParameterAST &source);
       
  1161 };
       
  1162 
       
  1163 class TemplateParameterListAST: public AST
       
  1164 {
       
  1165 public:
       
  1166     enum { Type = NodeType_TemplateParameterList };
       
  1167 
       
  1168 public:
       
  1169     TemplateParameterListAST();
       
  1170 
       
  1171     inline List<TemplateParameterAST *> *templateParameterList() const { return m_templateParameterList; }
       
  1172     void addTemplateParameter(TemplateParameterAST *templateParameter);
       
  1173 
       
  1174 private:
       
  1175     List<TemplateParameterAST *> *m_templateParameterList;
       
  1176 
       
  1177 private:
       
  1178     TemplateParameterListAST(const TemplateParameterListAST &source);
       
  1179     void operator = (const TemplateParameterListAST &source);
       
  1180 };
       
  1181 
       
  1182 class TemplateDeclarationAST: public DeclarationAST
       
  1183 {
       
  1184 public:
       
  1185     enum { Type = NodeType_TemplateDeclaration };
       
  1186 
       
  1187 public:
       
  1188     TemplateDeclarationAST();
       
  1189 
       
  1190     inline AST *exported() const { return m_exported; }
       
  1191     void setExported(AST *exported);
       
  1192 
       
  1193     inline TemplateParameterListAST *templateParameterList() const { return m_templateParameterList; }
       
  1194     void setTemplateParameterList(TemplateParameterListAST *templateParameterList);
       
  1195 
       
  1196     inline DeclarationAST *declaration() const { return m_declaration; }
       
  1197     void setDeclaration(DeclarationAST *declaration);
       
  1198 
       
  1199 private:
       
  1200     AST* m_exported;
       
  1201     TemplateParameterListAST* m_templateParameterList;
       
  1202     DeclarationAST* m_declaration;
       
  1203 
       
  1204 private:
       
  1205     TemplateDeclarationAST(const TemplateDeclarationAST &source);
       
  1206     void operator = (const TemplateDeclarationAST &source);
       
  1207 };
       
  1208 
       
  1209 class SimpleDeclarationAST: public DeclarationAST
       
  1210 {
       
  1211 public:
       
  1212     enum { Type = NodeType_SimpleDeclaration };
       
  1213 
       
  1214 public:
       
  1215     SimpleDeclarationAST();
       
  1216 
       
  1217     inline AST *functionSpecifier() const { return m_functionSpecifier; }
       
  1218     void setFunctionSpecifier(AST *functionSpecifier);
       
  1219 
       
  1220     inline AST *storageSpecifier() const { return m_storageSpecifier; }
       
  1221     void setStorageSpecifier(AST *storageSpecifier);
       
  1222 
       
  1223     inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; }
       
  1224     void setTypeSpec(TypeSpecifierAST *typeSpec);
       
  1225 
       
  1226     inline InitDeclaratorListAST *initDeclaratorList() const { return m_initDeclaratorList; }
       
  1227     void setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList);
       
  1228 
       
  1229     inline AST *winDeclSpec() const { return m_winDeclSpec; }
       
  1230     void setWinDeclSpec(AST *winDeclSpec);
       
  1231 
       
  1232 private:
       
  1233     AST* m_functionSpecifier;
       
  1234     AST* m_storageSpecifier;
       
  1235     TypeSpecifierAST* m_typeSpec;
       
  1236     InitDeclaratorListAST* m_initDeclaratorList;
       
  1237     AST* m_winDeclSpec;
       
  1238 
       
  1239 private:
       
  1240     SimpleDeclarationAST(const SimpleDeclarationAST &source);
       
  1241     void operator = (const SimpleDeclarationAST &source);
       
  1242 };
       
  1243 
       
  1244 class ExpressionStatementAST: public StatementAST
       
  1245 {
       
  1246 public:
       
  1247     enum { Type = NodeType_ExpressionStatement };
       
  1248 
       
  1249 public:
       
  1250     ExpressionStatementAST();
       
  1251 
       
  1252     inline AbstractExpressionAST *expression() const { return m_expression; }
       
  1253     void setExpression(AbstractExpressionAST *expression);
       
  1254 
       
  1255 private:
       
  1256     AbstractExpressionAST* m_expression;
       
  1257 
       
  1258 private:
       
  1259     ExpressionStatementAST(const ExpressionStatementAST &source);
       
  1260     void operator = (const ExpressionStatementAST &source);
       
  1261 };
       
  1262 
       
  1263 class ReturnStatementAST: public StatementAST
       
  1264 {
       
  1265 public:
       
  1266     enum { Type = NodeType_ReturnStatement };
       
  1267 
       
  1268 public:
       
  1269     ReturnStatementAST();
       
  1270 
       
  1271     inline AbstractExpressionAST *expression() const { return m_expression; }
       
  1272     void setExpression(AbstractExpressionAST *expression);
       
  1273 
       
  1274 private:
       
  1275     AbstractExpressionAST* m_expression;
       
  1276 
       
  1277 private:
       
  1278     ReturnStatementAST(const ReturnStatementAST &source);
       
  1279     void operator = (const ReturnStatementAST &source);
       
  1280 };
       
  1281 
       
  1282 
       
  1283 class ConditionAST: public AST
       
  1284 {
       
  1285 public:
       
  1286     enum { Type = NodeType_Condition };
       
  1287 
       
  1288 public:
       
  1289     ConditionAST();
       
  1290 
       
  1291     inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; }
       
  1292     void setTypeSpec(TypeSpecifierAST *typeSpec);
       
  1293 
       
  1294     inline DeclaratorAST *declarator() const { return m_declarator; }
       
  1295     void setDeclarator(DeclaratorAST *declarator);
       
  1296 
       
  1297     inline AbstractExpressionAST *expression() const { return m_expression; }
       
  1298     void setExpression(AbstractExpressionAST *expression);
       
  1299 
       
  1300 private:
       
  1301     TypeSpecifierAST* m_typeSpec;
       
  1302     DeclaratorAST* m_declarator;
       
  1303     AbstractExpressionAST* m_expression;
       
  1304 
       
  1305 private:
       
  1306     ConditionAST(const ConditionAST &source);
       
  1307     void operator = (const ConditionAST &source);
       
  1308 };
       
  1309 
       
  1310 class IfStatementAST: public StatementAST
       
  1311 {
       
  1312 public:
       
  1313     enum { Type = NodeType_IfStatement };
       
  1314 
       
  1315 public:
       
  1316     IfStatementAST();
       
  1317 
       
  1318     inline ConditionAST *condition() const { return m_condition; }
       
  1319     void setCondition(ConditionAST *condition);
       
  1320 
       
  1321     inline StatementAST *statement() const { return m_statement; }
       
  1322     void setStatement(StatementAST *statement);
       
  1323 
       
  1324     inline StatementAST *elseStatement() const { return m_elseStatement; }
       
  1325     void setElseStatement(StatementAST *statement);
       
  1326 
       
  1327 private:
       
  1328     ConditionAST* m_condition;
       
  1329     StatementAST* m_statement;
       
  1330     StatementAST* m_elseStatement;
       
  1331 
       
  1332 private:
       
  1333     IfStatementAST(const IfStatementAST &source);
       
  1334     void operator = (const IfStatementAST &source);
       
  1335 };
       
  1336 
       
  1337 class WhileStatementAST: public StatementAST
       
  1338 {
       
  1339 public:
       
  1340     enum { Type = NodeType_WhileStatement };
       
  1341 
       
  1342 public:
       
  1343     WhileStatementAST();
       
  1344 
       
  1345     inline ConditionAST *condition() const { return m_condition; }
       
  1346     void setCondition(ConditionAST *condition);
       
  1347 
       
  1348     inline StatementAST *statement() const { return m_statement; }
       
  1349     void setStatement(StatementAST *statement);
       
  1350 
       
  1351 private:
       
  1352     ConditionAST* m_condition;
       
  1353     StatementAST* m_statement;
       
  1354 
       
  1355 private:
       
  1356     WhileStatementAST(const WhileStatementAST &source);
       
  1357     void operator = (const WhileStatementAST &source);
       
  1358 };
       
  1359 
       
  1360 class DoStatementAST: public StatementAST
       
  1361 {
       
  1362 public:
       
  1363     enum { Type = NodeType_DoStatement };
       
  1364 
       
  1365 public:
       
  1366     DoStatementAST();
       
  1367 
       
  1368     inline ConditionAST *condition() const { return m_condition; }
       
  1369     void setCondition(ConditionAST *condition);
       
  1370 
       
  1371     inline StatementAST *statement() const { return m_statement; }
       
  1372     void setStatement(StatementAST *statement);
       
  1373 
       
  1374 private:
       
  1375     ConditionAST* m_condition;
       
  1376     StatementAST* m_statement;
       
  1377 
       
  1378 private:
       
  1379     DoStatementAST(const DoStatementAST &source);
       
  1380     void operator = (const DoStatementAST &source);
       
  1381 };
       
  1382 
       
  1383 class ForStatementAST: public StatementAST
       
  1384 {
       
  1385 public:
       
  1386     enum { Type = NodeType_ForStatement };
       
  1387 
       
  1388 public:
       
  1389     ForStatementAST();
       
  1390 
       
  1391     inline StatementAST *initStatement() const { return m_initStatement; }
       
  1392     void setInitStatement(StatementAST *statement);
       
  1393 
       
  1394     inline ConditionAST *condition() const { return m_condition; }
       
  1395     void setCondition(ConditionAST *condition);
       
  1396 
       
  1397     inline AbstractExpressionAST *expression() const { return m_expression; }
       
  1398     void setExpression(AbstractExpressionAST *expression);
       
  1399 
       
  1400     inline StatementAST *statement() const { return m_statement; }
       
  1401     void setStatement(StatementAST *statement);
       
  1402 
       
  1403 private:
       
  1404     ConditionAST* m_condition;
       
  1405     StatementAST* m_initStatement;
       
  1406     StatementAST* m_statement;
       
  1407     AbstractExpressionAST* m_expression;
       
  1408 
       
  1409 private:
       
  1410     ForStatementAST(const ForStatementAST &source);
       
  1411     void operator = (const ForStatementAST &source);
       
  1412 };
       
  1413 
       
  1414 class SwitchStatementAST: public StatementAST
       
  1415 {
       
  1416 public:
       
  1417     enum { Type = NodeType_SwitchStatement };
       
  1418 
       
  1419 public:
       
  1420     SwitchStatementAST();
       
  1421 
       
  1422     inline ConditionAST *condition() const { return m_condition; }
       
  1423     void setCondition(ConditionAST *condition);
       
  1424 
       
  1425     inline StatementAST *statement() const { return m_statement; }
       
  1426     void setStatement(StatementAST *statement);
       
  1427 
       
  1428 private:
       
  1429     ConditionAST* m_condition;
       
  1430     StatementAST* m_statement;
       
  1431 
       
  1432 private:
       
  1433     SwitchStatementAST(const SwitchStatementAST &source);
       
  1434     void operator = (const SwitchStatementAST &source);
       
  1435 };
       
  1436 
       
  1437 class StatementListAST: public StatementAST
       
  1438 {
       
  1439 public:
       
  1440     enum { Type = NodeType_StatementList };
       
  1441 
       
  1442 public:
       
  1443     StatementListAST();
       
  1444 
       
  1445     inline List<StatementAST *> *statementList() const { return m_statementList; }
       
  1446     void addStatement(StatementAST *statement);
       
  1447 
       
  1448 private:
       
  1449     List<StatementAST *> *m_statementList;
       
  1450 
       
  1451 private:
       
  1452     StatementListAST(const StatementListAST &source);
       
  1453     void operator = (const StatementListAST &source);
       
  1454 };
       
  1455 
       
  1456 class DeclarationStatementAST: public StatementAST
       
  1457 {
       
  1458 public:
       
  1459     enum { Type = NodeType_DeclarationStatement };
       
  1460 
       
  1461 public:
       
  1462     DeclarationStatementAST();
       
  1463 
       
  1464     inline DeclarationAST *declaration() const { return m_declaration; }
       
  1465     void setDeclaration(DeclarationAST *declaration);
       
  1466 
       
  1467 private:
       
  1468     DeclarationAST* m_declaration;
       
  1469 
       
  1470 private:
       
  1471     DeclarationStatementAST(const DeclarationStatementAST &source);
       
  1472     void operator = (const DeclarationStatementAST &source);
       
  1473 };
       
  1474 
       
  1475 /*
       
  1476     LabeledStatementAST:
       
  1477         case constant-expression : statement
       
  1478         default : statement (expression is 0)
       
  1479 */
       
  1480 class LabeledStatementAST: public StatementAST
       
  1481 {
       
  1482 public:
       
  1483     enum { Type = NodeType_LabeledStatement };
       
  1484 public:
       
  1485     LabeledStatementAST();
       
  1486 
       
  1487     inline StatementAST *statement() const { return m_statement; }
       
  1488     void setStatement(StatementAST *statement);
       
  1489 
       
  1490     inline AbstractExpressionAST *expression() const { return m_expression; }
       
  1491     void setExpression(AbstractExpressionAST *expression);
       
  1492 private:
       
  1493     StatementAST* m_statement;
       
  1494     AbstractExpressionAST *m_expression;
       
  1495 
       
  1496 private:
       
  1497     LabeledStatementAST(const LabeledStatementAST &source);
       
  1498     void operator = (const LabeledStatementAST &source);
       
  1499 };
       
  1500 
       
  1501 class FunctionDefinitionAST: public DeclarationAST
       
  1502 {
       
  1503 public:
       
  1504     enum { Type = NodeType_FunctionDefinition };
       
  1505 
       
  1506 public:
       
  1507     FunctionDefinitionAST();
       
  1508 
       
  1509     inline AST *functionSpecifier() const { return m_functionSpecifier; }
       
  1510     void setFunctionSpecifier(AST *functionSpecifier);
       
  1511 
       
  1512     inline AST *storageSpecifier() const { return m_storageSpecifier; }
       
  1513     void setStorageSpecifier(AST *storageSpecifier);
       
  1514 
       
  1515     inline TypeSpecifierAST *typeSpec() const { return m_typeSpec; }
       
  1516     void setTypeSpec(TypeSpecifierAST *typeSpec);
       
  1517 
       
  1518     inline InitDeclaratorAST *initDeclarator() const { return m_initDeclarator; }
       
  1519     void setInitDeclarator(InitDeclaratorAST *initDeclarator);
       
  1520 
       
  1521     inline StatementListAST *functionBody() const { return m_functionBody; }
       
  1522     void setFunctionBody(StatementListAST *functionBody);
       
  1523 
       
  1524     inline AST *winDeclSpec() const { return m_winDeclSpec; }
       
  1525     void setWinDeclSpec(AST *winDeclSpec);
       
  1526 
       
  1527 private:
       
  1528     AST* m_functionSpecifier;
       
  1529     AST* m_storageSpecifier;
       
  1530     TypeSpecifierAST* m_typeSpec;
       
  1531     InitDeclaratorAST* m_initDeclarator;
       
  1532     StatementListAST* m_functionBody;
       
  1533     AST* m_winDeclSpec;
       
  1534 
       
  1535 private:
       
  1536     FunctionDefinitionAST(const FunctionDefinitionAST &source);
       
  1537     void operator = (const FunctionDefinitionAST &source);
       
  1538 };
       
  1539 
       
  1540 class TranslationUnitAST: public AST
       
  1541 {
       
  1542 public:
       
  1543     enum { Type = NodeType_TranslationUnit };
       
  1544 
       
  1545 public:
       
  1546     TranslationUnitAST();
       
  1547 
       
  1548     void addDeclaration(DeclarationAST *ast);
       
  1549     inline List<DeclarationAST *> *declarationList() const { return m_declarationList; }
       
  1550 
       
  1551 private:
       
  1552     List<DeclarationAST *> *m_declarationList;
       
  1553 
       
  1554 private:
       
  1555     TranslationUnitAST(const TranslationUnitAST &source);
       
  1556     void operator = (const TranslationUnitAST &source);
       
  1557 };
       
  1558 
       
  1559 template <class T> T* CreateNode(pool *p)
       
  1560 {
       
  1561     T* node = new (p->allocate(sizeof(T))) T;
       
  1562     node->setNodeType(T::Type);
       
  1563     node->_pool = p;
       
  1564     return node;
       
  1565 }
       
  1566 
       
  1567 template <int kind> ExpressionAST<kind> *CreateExpression(pool *p)
       
  1568 {
       
  1569     ExpressionAST<kind>* node = new (p->allocate(sizeof(ExpressionAST<kind>))) ExpressionAST<kind>;
       
  1570     node->setNodeType(kind);
       
  1571     node->_pool = p;
       
  1572     return node;
       
  1573 }
       
  1574 
       
  1575 /*
       
  1576 template <typename T>
       
  1577 inline List<T *> *snoc(List<T *> *e, T *d, pool *p)
       
  1578 { if (!e) e = new (p->allocate(sizeof(List<T*>))) List<T *>(p); e->append(d); return e; }
       
  1579 */
       
  1580 
       
  1581 //Workaround for ICE on MSVC, use macro instead of template.
       
  1582 #define SNOC(ListType, ListValueType) \
       
  1583 inline ListType *snoc(ListType *e, ListValueType *d, pool *p) \
       
  1584 { if (!e) e = new (p->allocate(sizeof(ListType))) ListType(p); e->append(d); return e; }
       
  1585 
       
  1586 SNOC(List<AST *>, AST)
       
  1587 SNOC(List<ClassOrNamespaceNameAST *>, ClassOrNamespaceNameAST)
       
  1588 SNOC(List<BaseSpecifierAST *>, BaseSpecifierAST)
       
  1589 SNOC(List<DeclarationAST *>, DeclarationAST)
       
  1590 SNOC(List<EnumeratorAST *>, EnumeratorAST)
       
  1591 SNOC(List<ParameterDeclarationAST *>, ParameterDeclarationAST)
       
  1592 SNOC(List<InitDeclaratorAST *>, InitDeclaratorAST)
       
  1593 SNOC(List<TemplateParameterAST *>, TemplateParameterAST)
       
  1594 SNOC(List<StatementAST *>, StatementAST)
       
  1595 
       
  1596 QT_END_NAMESPACE
       
  1597 
       
  1598 #endif // AST_H