KDevelop API Documentation

ast.h

Go to the documentation of this file.
00001 /* This file is part of KDevelop
00002     Copyright (C) 2002,2003 Roberto Raggi <roberto@kdevelop.org>
00003 
00004     This library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation; either
00007     version 2 of the License, or (at your option) any later version.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017     Boston, MA 02111-1307, USA.
00018 */
00019 
00020 #ifndef __ast_h
00021 #define __ast_h
00022 
00023 #include <memory>
00024 #include <qstring.h>
00025 #include <qptrlist.h>
00026 
00027 #if defined( Q_OS_WIN32 ) || defined( Q_CC_SUN )
00028 
00029 #ifndef _THROW0
00030 #  define _THROW0()
00031 #endif
00032 
00033 template <class _Tp> class AUTO_PTR {
00034 private:
00035     _Tp* _M_ptr;
00036 
00037 public:
00038     typedef _Tp element_type;
00039 
00040     explicit AUTO_PTR(_Tp* __p = 0)  _THROW0() : _M_ptr(__p) {}
00041 
00042     template <class _Tp1> AUTO_PTR(AUTO_PTR<_Tp1>& __a)  _THROW0()
00043     : _M_ptr(__a.release()) {}
00044 
00045     AUTO_PTR(AUTO_PTR& __a)  _THROW0() : _M_ptr(__a.release()) {}
00046 
00047 
00048 
00049     template <class _Tp1>
00050     AUTO_PTR& operator=(AUTO_PTR<_Tp1>& __a)  _THROW0() {
00051     if (__a.get() != this->get()) {
00052         delete _M_ptr;
00053         _M_ptr = __a.release();
00054     }
00055     return *this;
00056     }
00057 
00058     AUTO_PTR& operator=(AUTO_PTR& __a)  _THROW0() {
00059     if (&__a != this) {
00060         delete _M_ptr;
00061         _M_ptr = __a.release();
00062     }
00063     return *this;
00064     }
00065 
00066     ~AUTO_PTR()  _THROW0() { delete _M_ptr; }
00067 
00068     _Tp& operator*() const  _THROW0() {
00069     return *_M_ptr;
00070     }
00071     _Tp* operator->() const  _THROW0() {
00072     return _M_ptr;
00073     }
00074     _Tp* get() const  _THROW0() {
00075     return _M_ptr;
00076     }
00077     _Tp* release()  _THROW0() {
00078     _Tp* __tmp = _M_ptr;
00079     _M_ptr = 0;
00080     return __tmp;
00081     }
00082     void reset(_Tp* __p = 0)  _THROW0() {
00083     delete _M_ptr;
00084     _M_ptr = __p;
00085     }
00086 
00087     // According to the C++ standard, these conversions are required.  Most
00088     // present-day compilers, however, do not enforce that requirement---and,
00089     // in fact, most present-day compilers do not support the language
00090     // features that these conversions rely on.
00091 
00092 
00093 private:
00094     template<class _Tp1> struct AUTO_PTR_ref {
00095     _Tp1* _M_ptr;
00096     AUTO_PTR_ref(_Tp1* __p) : _M_ptr(__p) {}
00097     };
00098 
00099 public:
00100     AUTO_PTR(AUTO_PTR_ref<_Tp> __ref)  _THROW0()
00101     : _M_ptr(__ref._M_ptr) {}
00102     template <class _Tp1> operator AUTO_PTR_ref<_Tp1>()  _THROW0()
00103     { return AUTO_PTR_ref<_Tp>(this->release()); }
00104     template <class _Tp1> operator AUTO_PTR<_Tp1>()  _THROW0()
00105     { return AUTO_PTR<_Tp1>(this->release()) }
00106 
00107 };
00108 
00109 #else
00110 #define AUTO_PTR std::auto_ptr
00111 #endif
00112 
00113 template <class T> typename T::Node CreateNode()
00114 {
00115     typename T::Node node( new T );
00116     node->setNodeType( T::Type );
00117     return node;
00118 }
00119 
00120 template <class T> typename T::Node NullNode()
00121 {
00122     typename T::Node node;
00123     return node;
00124 }
00125 
00126 enum NodeType
00127 {
00128     NodeType_Generic = 0,
00129 
00130     NodeType_TemplateArgumentList = 1000,
00131     NodeType_ClassOrNamespaceName,
00132     NodeType_Name,
00133     NodeType_Declaration,
00134     NodeType_TypeSpecifier,
00135     NodeType_BaseSpecifier,
00136     NodeType_BaseClause,
00137     NodeType_ClassSpecifier,
00138     NodeType_Enumerator,
00139     NodeType_EnumSpecifier,
00140     NodeType_ElaboratedTypeSpecifier,
00141     NodeType_LinkageBody,
00142     NodeType_LinkageSpecification,
00143     NodeType_Namespace,
00144     NodeType_NamespaceAlias,
00145     NodeType_Using,
00146     NodeType_UsingDirective,
00147     NodeType_InitDeclaratorList,
00148     NodeType_Typedef,
00149     NodeType_Declarator,
00150     NodeType_InitDeclarator,
00151     NodeType_TemplateDeclaration,
00152     NodeType_SimpleDeclaration,
00153     NodeType_Statement,
00154     NodeType_StatementList,
00155     NodeType_IfStatement,
00156     NodeType_WhileStatement,
00157     NodeType_DoStatement,
00158     NodeType_ForStatement,
00159     NodeType_SwitchStatement,
00160     NodeType_DeclarationStatement,
00161     NodeType_TranslationUnit,
00162     NodeType_FunctionDefinition,
00163     NodeType_ExpressionStatement,
00164     NodeType_ParameterDeclaration,
00165     NodeType_ParameterDeclarationList,
00166     NodeType_ParameterDeclarationClause,
00167     NodeType_Group,
00168     NodeType_AccessDeclaration,
00169     NodeType_TypeParameter,
00170     NodeType_TemplateParameter,
00171     NodeType_TemplateParameterList,
00172     NodeType_Condition,
00173 
00174     NodeType_Custom = 2000
00175 };
00176 
00177 QString nodeTypeToString( int type );
00178 
00179 
00180 #if defined(CPPPARSER_QUICK_ALLOCATOR)
00181 
00182 #include <quick_allocator.h>
00183 
00184 #define DECLARE_ALLOC(tp) \
00185     void * operator new(std::size_t) \
00186     { \
00187         return quick_allocator< tp >::alloc(); \
00188     } \
00189  \
00190     void operator delete(void * p) \
00191     { \
00192         quick_allocator< tp >::dealloc(p); \
00193     }
00194 #else
00195 
00196 #define DECLARE_ALLOC(tp)
00197 
00198 #endif
00199 
00200 struct Slice
00201 {
00202     QString source;
00203     int position;
00204     int length;
00205     
00206     inline Slice()
00207         : position(0), length(0) {}
00208 };
00209 
00210 class AST
00211 {
00212 public:
00213     typedef AUTO_PTR<AST> Node;
00214     enum { Type=NodeType_Generic };
00215     
00216     DECLARE_ALLOC( AST )
00217 
00218 public:
00219     AST();
00220     virtual ~AST();
00221 
00222     int nodeType() const { return m_nodeType; }
00223     void setNodeType( int nodeType ) { m_nodeType = nodeType; }
00224 
00225     AST* parent() { return m_parent; }
00226     void setParent( AST* parent );
00227 
00228     void setStartPosition( int line, int col );
00229     void getStartPosition( int* line, int* col ) const;
00230 
00231     void setEndPosition( int line, int col );
00232     void getEndPosition( int* line, int* col ) const;
00233 
00234 #ifndef CPPPARSER_NO_CHILDREN
00235     QPtrList<AST> children() { return m_children; }
00236     void appendChild( AST* child );
00237     void removeChild( AST* child );
00238 #endif
00239 
00240     virtual inline QString text() const 
00241     { return m_slice.source.mid(m_slice.position, m_slice.length); }
00242     
00243     inline void setSlice( const Slice& slice ) 
00244     { m_slice = slice; }
00245 
00246     inline void setSlice( const QString &text, int position, int length ) 
00247     {
00248         m_slice.source = text;
00249         m_slice.position = position;
00250         m_slice.length = length;
00251     }
00252     
00253     inline void setText(const QString &text)
00254     { setSlice(text, 0, text.length()); }
00255 
00256 private:
00257     int m_nodeType;
00258     AST* m_parent;
00259     int m_startLine, m_startColumn;
00260     int m_endLine, m_endColumn;
00261     Slice m_slice;
00262 #ifndef CPPPARSER_NO_CHILDREN
00263     QPtrList<AST> m_children;
00264 #endif
00265 
00266 private:
00267     AST( const AST& source );
00268     void operator = ( const AST& source );
00269 };
00270 
00271 class GroupAST: public AST
00272 {
00273 public:
00274     typedef AUTO_PTR<GroupAST> Node;
00275     enum { Type = NodeType_Group };
00276 
00277     DECLARE_ALLOC( GroupAST )
00278     
00279 public:
00280     GroupAST();
00281 
00282     QPtrList<AST> nodeList() { return m_nodeList; }
00283     void addNode( AST::Node& node );
00284 
00285     virtual QString text() const;
00286 
00287 private:
00288     QPtrList<AST> m_nodeList;
00289 
00290 private:
00291     GroupAST( const GroupAST& source );
00292     void operator = ( const GroupAST& source );
00293 };
00294 
00295 
00296 class TemplateArgumentListAST: public AST
00297 {
00298 public:
00299     typedef AUTO_PTR<TemplateArgumentListAST> Node;
00300     enum { Type = NodeType_TemplateArgumentList };
00301 
00302     DECLARE_ALLOC( TemplateArgumentListAST )
00303     
00304 public:
00305     TemplateArgumentListAST();
00306 
00307     void addArgument( AST::Node& arg );
00308     QPtrList<AST> argumentList() { return m_argumentList; }
00309 
00310     virtual QString text() const;
00311 
00312 private:
00313     QPtrList<AST> m_argumentList;
00314 
00315 private:
00316     TemplateArgumentListAST( const TemplateArgumentListAST& source );
00317     void operator = ( const TemplateArgumentListAST& source );
00318 };
00319 
00320 class ClassOrNamespaceNameAST: public AST
00321 {
00322 public:
00323     typedef AUTO_PTR<ClassOrNamespaceNameAST> Node;
00324     enum { Type = NodeType_ClassOrNamespaceName };
00325 
00326     DECLARE_ALLOC( ClassOrNamespaceNameAST )
00327     
00328 public:
00329     ClassOrNamespaceNameAST();
00330 
00331     AST* name() { return m_name.get(); }
00332     void setName( AST::Node& name );
00333 
00334     TemplateArgumentListAST* templateArgumentList() { return m_templateArgumentList.get(); }
00335     void setTemplateArgumentList( TemplateArgumentListAST::Node& templateArgumentList );
00336 
00337     virtual QString text() const;
00338 
00339 private:
00340     AST::Node m_name;
00341     TemplateArgumentListAST::Node m_templateArgumentList;
00342 
00343 private:
00344     ClassOrNamespaceNameAST( const ClassOrNamespaceNameAST& source );
00345     void operator = ( const ClassOrNamespaceNameAST& source );
00346 };
00347 
00348 class NameAST: public AST
00349 {
00350 public:
00351     typedef AUTO_PTR<NameAST> Node;
00352     enum { Type = NodeType_Name };
00353 
00354     DECLARE_ALLOC( NameAST )
00355     
00356 public:
00357     NameAST();
00358 
00359     bool isGlobal() const { return m_global; }
00360     void setGlobal( bool b );
00361 
00362     void addClassOrNamespaceName( ClassOrNamespaceNameAST::Node& classOrNamespaceName );
00363     QPtrList<ClassOrNamespaceNameAST> classOrNamespaceNameList() { return m_classOrNamespaceNameList; }
00364 
00365     ClassOrNamespaceNameAST* unqualifiedName() { return m_unqualifiedName.get(); }
00366     void setUnqualifiedName( ClassOrNamespaceNameAST::Node& unqualifiedName );
00367 
00368     virtual QString text() const;
00369 
00370 private:
00371     bool m_global;
00372     ClassOrNamespaceNameAST::Node m_unqualifiedName;
00373     QPtrList<ClassOrNamespaceNameAST> m_classOrNamespaceNameList;
00374 
00375 private:
00376     NameAST( const NameAST& source );
00377     void operator = ( const NameAST& source );
00378 };
00379 
00380 class TypeParameterAST: public AST
00381 {
00382 public:
00383     typedef AUTO_PTR<TypeParameterAST> Node;
00384     enum { Type = NodeType_TypeParameter };
00385 
00386     DECLARE_ALLOC( TypeParameterAST )
00387     
00388 public:
00389     TypeParameterAST();
00390 
00391     AST* kind() { return m_kind.get(); }
00392     void setKind( AST::Node& kind );
00393 
00394     class TemplateParameterListAST* templateParameterList() { return m_templateParameterList.get(); }
00395     void setTemplateParameterList( AUTO_PTR<class TemplateParameterListAST>& templateParameterList );
00396 
00397     NameAST* name() { return m_name.get(); }
00398     void setName( NameAST::Node& name );
00399 
00400     AST* typeId() { return m_typeId.get(); }
00401     void setTypeId( AST::Node& typeId );
00402 
00403 private:
00404     AST::Node m_kind;
00405     AUTO_PTR<class TemplateParameterListAST> m_templateParameterList;
00406     NameAST::Node m_name;
00407     AST::Node m_typeId;
00408 
00409 private:
00410     TypeParameterAST( const TypeParameterAST& source );
00411     void operator = ( const TypeParameterAST& source );
00412 };
00413 
00414 class DeclarationAST: public AST
00415 {
00416 public:
00417     typedef AUTO_PTR<DeclarationAST> Node;
00418     enum { Type = NodeType_Declaration };
00419 
00420     DECLARE_ALLOC( DeclarationAST )
00421     
00422 public:
00423     DeclarationAST();
00424 
00425 private:
00426     DeclarationAST( const DeclarationAST& source );
00427     void operator = ( const DeclarationAST& source );
00428 };
00429 
00430 class AccessDeclarationAST: public DeclarationAST
00431 {
00432 public:
00433     typedef AUTO_PTR<AccessDeclarationAST> Node;
00434     enum { Type = NodeType_AccessDeclaration };
00435 
00436     DECLARE_ALLOC( AccessDeclarationAST )
00437     
00438 public:
00439     AccessDeclarationAST();
00440 
00441     QPtrList<AST> accessList() { return m_accessList; }
00442     void addAccess( AST::Node& access );
00443 
00444     virtual QString text() const;
00445 
00446 private:
00447     QPtrList<AST> m_accessList;
00448 
00449 private:
00450     AccessDeclarationAST( const AccessDeclarationAST& source );
00451     void operator = ( const AccessDeclarationAST& source );
00452 };
00453 
00454 class TypeSpecifierAST: public AST
00455 {
00456 public:
00457     typedef AUTO_PTR<TypeSpecifierAST> Node;
00458     enum { Type = NodeType_TypeSpecifier };
00459 
00460     DECLARE_ALLOC( TypeSpecifierAST )
00461     
00462 public:
00463     TypeSpecifierAST();
00464 
00465     virtual NameAST* name() { return m_name.get(); }
00466     virtual void setName( NameAST::Node& name );
00467 
00468     GroupAST* cvQualify() { return m_cvQualify.get(); }
00469     void setCvQualify( GroupAST::Node& cvQualify );
00470 
00471     GroupAST* cv2Qualify() { return m_cv2Qualify.get(); }
00472     void setCv2Qualify( GroupAST::Node& cv2Qualify );
00473 
00474     virtual QString text() const;
00475 
00476 private:
00477     NameAST::Node m_name;
00478     GroupAST::Node m_cvQualify;
00479     GroupAST::Node m_cv2Qualify;
00480 
00481 private:
00482     TypeSpecifierAST( const TypeSpecifierAST& source );
00483     void operator = ( const TypeSpecifierAST& source );
00484 };
00485 
00486 class BaseSpecifierAST: public AST
00487 {
00488 public:
00489     typedef AUTO_PTR<BaseSpecifierAST> Node;
00490     enum { Type = NodeType_BaseSpecifier };
00491 
00492     DECLARE_ALLOC( BaseSpecifierAST )
00493     
00494 public:
00495     BaseSpecifierAST();
00496 
00497     AST* isVirtual() { return m_isVirtual.get(); }
00498     void setIsVirtual( AST::Node& isVirtual );
00499 
00500     AST* access() { return m_access.get(); }
00501     void setAccess( AST::Node& access );
00502 
00503     NameAST* name() { return m_name.get(); }
00504     void setName( NameAST::Node& name );
00505 
00506 private:
00507     AST::Node m_isVirtual;
00508     AST::Node m_access;
00509     NameAST::Node m_name;
00510 
00511 private:
00512     BaseSpecifierAST( const BaseSpecifierAST& source );
00513     void operator = ( const BaseSpecifierAST& source );
00514 };
00515 
00516 class BaseClauseAST: public AST
00517 {
00518 public:
00519     typedef AUTO_PTR<BaseClauseAST> Node;
00520     enum { Type = NodeType_BaseClause };
00521 
00522     DECLARE_ALLOC( BaseClauseAST )
00523     
00524 public:
00525     BaseClauseAST();
00526 
00527     void addBaseSpecifier( BaseSpecifierAST::Node& baseSpecifier );
00528     QPtrList<BaseSpecifierAST> baseSpecifierList() { return m_baseSpecifierList; }
00529 
00530 private:
00531     QPtrList<BaseSpecifierAST> m_baseSpecifierList;
00532 
00533 private:
00534     BaseClauseAST( const BaseClauseAST& source );
00535     void operator = ( const BaseClauseAST& source );
00536 };
00537 
00538 class ClassSpecifierAST: public TypeSpecifierAST
00539 {
00540 public:
00541     typedef AUTO_PTR<ClassSpecifierAST> Node;
00542     enum { Type = NodeType_ClassSpecifier };
00543 
00544     DECLARE_ALLOC( ClassSpecifierAST )
00545     
00546 public:
00547     ClassSpecifierAST();
00548 
00549     GroupAST* winDeclSpec() { return m_winDeclSpec.get(); }
00550     void setWinDeclSpec( GroupAST::Node& winDeclSpec );
00551 
00552     AST* classKey() { return m_classKey.get(); }
00553     void setClassKey( AST::Node& classKey );
00554 
00555     BaseClauseAST* baseClause() { return m_baseClause.get(); }
00556     void setBaseClause( BaseClauseAST::Node& baseClause );
00557 
00558     QPtrList<DeclarationAST> declarationList() { return m_declarationList; }
00559     void addDeclaration( DeclarationAST::Node& declaration );
00560 
00561 private:
00562     GroupAST::Node m_winDeclSpec;
00563     AST::Node m_classKey;
00564     BaseClauseAST::Node m_baseClause;
00565     QPtrList<DeclarationAST> m_declarationList;
00566 
00567 private:
00568     ClassSpecifierAST( const ClassSpecifierAST& source );
00569     void operator = ( const ClassSpecifierAST& source );
00570 };
00571 
00572 class EnumeratorAST: public AST
00573 {
00574 public:
00575     typedef AUTO_PTR<EnumeratorAST> Node;
00576     enum { Type = NodeType_Enumerator };
00577 
00578     DECLARE_ALLOC( EnumeratorAST )
00579     
00580 public:
00581     EnumeratorAST();
00582 
00583     AST* id() { return m_id.get(); }
00584     void setId( AST::Node& id );
00585 
00586     AST* expr() { return m_expr.get(); }
00587     void setExpr( AST::Node& expr );
00588 
00589 private:
00590     AST::Node m_id;
00591     AST::Node m_expr;
00592 
00593 private:
00594     EnumeratorAST( const EnumeratorAST& source );
00595     void operator = ( const EnumeratorAST& source );
00596 };
00597 
00598 class EnumSpecifierAST: public TypeSpecifierAST
00599 {
00600 public:
00601     typedef AUTO_PTR<EnumSpecifierAST> Node;
00602     enum { Type = NodeType_EnumSpecifier };
00603 
00604     DECLARE_ALLOC( EnumSpecifierAST )
00605     
00606 public:
00607     EnumSpecifierAST();
00608 
00609     void addEnumerator( EnumeratorAST::Node& enumerator );
00610     QPtrList<EnumeratorAST> enumeratorList() { return m_enumeratorList; }
00611 
00612 private:
00613     QPtrList<EnumeratorAST> m_enumeratorList;
00614 
00615 private:
00616     EnumSpecifierAST( const EnumSpecifierAST& source );
00617     void operator = ( const EnumSpecifierAST& source );
00618 };
00619 
00620 class ElaboratedTypeSpecifierAST: public TypeSpecifierAST
00621 {
00622 public:
00623     typedef AUTO_PTR<ElaboratedTypeSpecifierAST> Node;
00624     enum { Type = NodeType_ElaboratedTypeSpecifier };
00625 
00626     DECLARE_ALLOC( ElaboratedTypeSpecifierAST )
00627     
00628 public:
00629     ElaboratedTypeSpecifierAST();
00630 
00631     AST* kind() { return m_kind.get(); }
00632     void setKind( AST::Node& kind );
00633 
00634     virtual QString text() const;
00635 
00636 private:
00637     AST::Node m_kind;
00638 
00639 private:
00640     ElaboratedTypeSpecifierAST( const ElaboratedTypeSpecifierAST& source );
00641     void operator = ( const ElaboratedTypeSpecifierAST& source );
00642 };
00643 
00644 
00645 class LinkageBodyAST: public AST
00646 {
00647 public:
00648     typedef AUTO_PTR<LinkageBodyAST> Node;
00649     enum { Type = NodeType_LinkageBody };
00650 
00651     DECLARE_ALLOC( LinkageBodyAST )
00652     
00653 public:
00654     LinkageBodyAST();
00655 
00656     void addDeclaration( DeclarationAST::Node& ast );
00657     QPtrList<DeclarationAST> declarationList() { return m_declarationList; }
00658 
00659 private:
00660     QPtrList<DeclarationAST> m_declarationList;
00661 
00662 private:
00663     LinkageBodyAST( const LinkageBodyAST& source );
00664     void operator = ( const LinkageBodyAST& source );
00665 };
00666 
00667 class LinkageSpecificationAST: public DeclarationAST
00668 {
00669 public:
00670     typedef AUTO_PTR<LinkageSpecificationAST> Node;
00671     enum { Type = NodeType_LinkageSpecification };
00672 
00673     DECLARE_ALLOC( LinkageSpecificationAST )
00674     
00675 public:
00676     LinkageSpecificationAST();
00677 
00678     AST* externType() { return m_externType.get(); }
00679     void setExternType( AST::Node& externType );
00680 
00681     LinkageBodyAST* linkageBody() { return m_linkageBody.get(); }
00682     void setLinkageBody( LinkageBodyAST::Node& linkageBody );
00683 
00684     DeclarationAST* declaration() { return m_declaration.get(); }
00685     void setDeclaration( DeclarationAST::Node& decl );
00686 
00687 private:
00688     AST::Node m_externType;
00689     LinkageBodyAST::Node m_linkageBody;
00690     DeclarationAST::Node m_declaration;
00691 
00692 private:
00693     LinkageSpecificationAST( const LinkageSpecificationAST& source );
00694     void operator = ( const LinkageSpecificationAST& source );
00695 };
00696 
00697 class NamespaceAST: public DeclarationAST
00698 {
00699 public:
00700     typedef AUTO_PTR<NamespaceAST> Node;
00701     enum { Type = NodeType_Namespace };
00702 
00703     DECLARE_ALLOC( NamespaceAST )
00704     
00705 public:
00706     NamespaceAST();
00707 
00708     AST* namespaceName() { return m_namespaceName.get(); }
00709     void setNamespaceName( AST::Node& namespaceName );
00710 
00711     LinkageBodyAST* linkageBody() { return m_linkageBody.get(); }
00712     void setLinkageBody( LinkageBodyAST::Node& linkageBody );
00713 
00714 private:
00715     AST::Node m_namespaceName;
00716     LinkageBodyAST::Node m_linkageBody;
00717 
00718 private:
00719     NamespaceAST( const NamespaceAST& source );
00720     void operator = ( const NamespaceAST& source );
00721 };
00722 
00723 class NamespaceAliasAST: public DeclarationAST
00724 {
00725 public:
00726     typedef AUTO_PTR<NamespaceAliasAST> Node;
00727     enum { Type = NodeType_NamespaceAlias };
00728 
00729     DECLARE_ALLOC( NamespaceAliasAST )
00730     
00731 public:
00732     NamespaceAliasAST();
00733 
00734     AST* namespaceName() { return m_namespaceName.get(); }
00735     void setNamespaceName( AST::Node& name );
00736 
00737     NameAST* aliasName() { return m_aliasName.get(); }
00738     void setAliasName( NameAST::Node& name );
00739 
00740 private:
00741     AST::Node m_namespaceName;
00742     NameAST::Node m_aliasName;
00743 
00744 private:
00745     NamespaceAliasAST( const NamespaceAliasAST& source );
00746     void operator = ( const NamespaceAliasAST& source );
00747 };
00748 
00749 class UsingAST: public DeclarationAST
00750 {
00751 public:
00752     typedef AUTO_PTR<UsingAST> Node;
00753     enum { Type = NodeType_Using };
00754 
00755     DECLARE_ALLOC( UsingAST )
00756     
00757 public:
00758     UsingAST();
00759 
00760     AST* typeName() { return m_typeName.get(); }
00761     void setTypeName( AST::Node& typeName );
00762 
00763     NameAST* name() { return m_name.get(); }
00764     void setName( NameAST::Node& name );
00765 
00766 private:
00767     AST::Node m_typeName;
00768     NameAST::Node m_name;
00769 
00770 private:
00771     UsingAST( const UsingAST& source );
00772     void operator = ( const UsingAST& source );
00773 };
00774 
00775 class UsingDirectiveAST: public DeclarationAST
00776 {
00777 public:
00778     typedef AUTO_PTR<UsingDirectiveAST> Node;
00779     enum { Type = NodeType_UsingDirective };
00780 
00781     DECLARE_ALLOC( UsingDirectiveAST )
00782     
00783 public:
00784     UsingDirectiveAST();
00785 
00786     NameAST* name() { return m_name.get(); }
00787     void setName( NameAST::Node& name );
00788 
00789 private:
00790     NameAST::Node m_name;
00791 
00792 private:
00793     UsingDirectiveAST( const UsingDirectiveAST& source );
00794     void operator = ( const UsingDirectiveAST& source );
00795 };
00796 
00797 class DeclaratorAST: public AST
00798 {
00799 public:
00800     typedef AUTO_PTR<DeclaratorAST> Node;
00801     enum { Type = NodeType_Declarator };
00802 
00803     DECLARE_ALLOC( DeclaratorAST )
00804     
00805 public:
00806     DeclaratorAST();
00807 
00808     QPtrList<AST> ptrOpList() { return m_ptrOpList; }
00809     void addPtrOp( AST::Node& ptrOp );
00810 
00811     DeclaratorAST* subDeclarator() { return m_subDeclarator.get(); }
00812     void setSubDeclarator( AUTO_PTR<DeclaratorAST>& subDeclarator );
00813 
00814     NameAST* declaratorId() { return m_declaratorId.get(); }
00815     void setDeclaratorId( NameAST::Node& declaratorId );
00816 
00817     AST* bitfieldInitialization() { return m_bitfieldInitialization.get(); }
00818     void setBitfieldInitialization( AST::Node& bitfieldInitialization );
00819 
00820     QPtrList<AST> arrayDimensionList() { return m_arrayDimensionList; }
00821     void addArrayDimension( AST::Node& arrayDimension );
00822 
00823     class ParameterDeclarationClauseAST* parameterDeclarationClause() { return m_parameterDeclarationClause.get(); }
00824     void setParameterDeclarationClause( AUTO_PTR<class ParameterDeclarationClauseAST>& parameterDeclarationClause );
00825 
00826     // ### replace 'constant' with cvQualify
00827     AST* constant() { return m_constant.get(); }
00828     void setConstant( AST::Node& constant );
00829 
00830     GroupAST* exceptionSpecification() { return m_exceptionSpecification.get(); }
00831     void setExceptionSpecification( GroupAST::Node& exceptionSpecification );
00832 
00833 private:
00834     QPtrList<AST> m_ptrOpList;
00835     AUTO_PTR<DeclaratorAST> m_subDeclarator;
00836     NameAST::Node m_declaratorId;
00837     AST::Node m_bitfieldInitialization;
00838     QPtrList<AST> m_arrayDimensionList;
00839     AUTO_PTR<class ParameterDeclarationClauseAST> m_parameterDeclarationClause;
00840     AST::Node m_constant;
00841     GroupAST::Node m_exceptionSpecification;
00842 
00843 private:
00844     DeclaratorAST( const DeclaratorAST& source );
00845     void operator = ( const DeclaratorAST& source );
00846 };
00847 
00848 class ParameterDeclarationAST: public AST
00849 {
00850 public:
00851     typedef AUTO_PTR<ParameterDeclarationAST> Node;
00852     enum { Type = NodeType_ParameterDeclaration };
00853 
00854     DECLARE_ALLOC( ParameterDeclarationAST )
00855     
00856 public:
00857     ParameterDeclarationAST();
00858 
00859     TypeSpecifierAST* typeSpec() { return m_typeSpec.get(); }
00860     void setTypeSpec( TypeSpecifierAST::Node& typeSpec );
00861 
00862     DeclaratorAST* declarator() { return m_declarator.get(); }
00863     void setDeclarator( DeclaratorAST::Node& declarator );
00864 
00865     AST* expression() { return m_expression.get(); }
00866     void setExpression( AST::Node& expression );
00867 
00868     virtual QString text() const;
00869 
00870 private:
00871     TypeSpecifierAST::Node m_typeSpec;
00872     DeclaratorAST::Node m_declarator;
00873     AST::Node m_expression;
00874 
00875 private:
00876     ParameterDeclarationAST( const ParameterDeclarationAST& source );
00877     void operator = ( const ParameterDeclarationAST& source );
00878 };
00879 
00880 class ParameterDeclarationListAST: public AST
00881 {
00882 public:
00883     typedef AUTO_PTR<ParameterDeclarationListAST> Node;
00884     enum { Type = NodeType_ParameterDeclarationList };
00885 
00886     DECLARE_ALLOC( ParameterDeclarationListAST )
00887     
00888 public:
00889     ParameterDeclarationListAST();
00890 
00891     QPtrList<ParameterDeclarationAST> parameterList() { return m_parameterList; }
00892     void addParameter( ParameterDeclarationAST::Node& parameter );
00893 
00894     virtual QString text() const;
00895 
00896 private:
00897     QPtrList<ParameterDeclarationAST> m_parameterList;
00898 
00899 private:
00900     ParameterDeclarationListAST( const ParameterDeclarationListAST& source );
00901     void operator = ( const ParameterDeclarationListAST& source );
00902 };
00903 
00904 class ParameterDeclarationClauseAST: public AST
00905 {
00906 public:
00907     typedef AUTO_PTR<ParameterDeclarationClauseAST> Node;
00908     enum { Type = NodeType_ParameterDeclarationClause };
00909 
00910     DECLARE_ALLOC( ParameterDeclarationClauseAST )
00911     
00912 public:
00913     ParameterDeclarationClauseAST();
00914 
00915     ParameterDeclarationListAST* parameterDeclarationList() { return m_parameterDeclarationList.get(); }
00916     void setParameterDeclarationList( ParameterDeclarationListAST::Node& parameterDeclarationList );
00917 
00918     AST* ellipsis() { return m_ellipsis.get(); }
00919     void setEllipsis( AST::Node& ellipsis );
00920 
00921     virtual QString text() const;
00922 
00923 private:
00924     ParameterDeclarationListAST::Node m_parameterDeclarationList;
00925     AST::Node m_ellipsis;
00926 
00927 private:
00928     ParameterDeclarationClauseAST( const ParameterDeclarationClauseAST& source );
00929     void operator = ( const ParameterDeclarationClauseAST& source );
00930 };
00931 
00932 
00933 class InitDeclaratorAST: public AST
00934 {
00935 public:
00936     typedef AUTO_PTR<InitDeclaratorAST> Node;
00937     enum { Type = NodeType_InitDeclarator };
00938 
00939     DECLARE_ALLOC( InitDeclaratorAST )
00940     
00941 public:
00942     InitDeclaratorAST();
00943 
00944     DeclaratorAST* declarator() { return m_declarator.get(); }
00945     void setDeclarator( DeclaratorAST::Node& declarator );
00946 
00947     AST* initializer() { return m_initializer.get(); }
00948     void setInitializer( AST::Node& initializer );
00949 
00950 private:
00951     DeclaratorAST::Node m_declarator;
00952     AST::Node m_initializer;
00953 
00954 private:
00955     InitDeclaratorAST( const InitDeclaratorAST& source );
00956     void operator = ( const InitDeclaratorAST& source );
00957 };
00958 
00959 class InitDeclaratorListAST: public AST
00960 {
00961 public:
00962     typedef AUTO_PTR<InitDeclaratorListAST> Node;
00963     enum { Type = NodeType_InitDeclaratorList };
00964 
00965     DECLARE_ALLOC( InitDeclaratorListAST )
00966     
00967 public:
00968     InitDeclaratorListAST();
00969 
00970     QPtrList<InitDeclaratorAST> initDeclaratorList() { return m_initDeclaratorList; }
00971     void addInitDeclarator( InitDeclaratorAST::Node& decl );
00972 
00973 private:
00974     QPtrList<InitDeclaratorAST> m_initDeclaratorList;
00975 
00976 private:
00977     InitDeclaratorListAST( const InitDeclaratorListAST& source );
00978     void operator = ( const InitDeclaratorListAST& source );
00979 };
00980 
00981 class TypedefAST: public DeclarationAST
00982 {
00983 public:
00984     typedef AUTO_PTR<TypedefAST> Node;
00985     enum { Type = NodeType_Typedef };
00986 
00987     DECLARE_ALLOC( TypedefAST )
00988     
00989 public:
00990     TypedefAST();
00991 
00992     TypeSpecifierAST* typeSpec() { return m_typeSpec.get(); }
00993     void setTypeSpec( TypeSpecifierAST::Node& typeSpec );
00994 
00995     InitDeclaratorListAST* initDeclaratorList() { return m_initDeclaratorList.get(); }
00996     void setInitDeclaratorList( InitDeclaratorListAST::Node& initDeclaratorList );
00997 
00998 private:
00999     TypeSpecifierAST::Node m_typeSpec;
01000     InitDeclaratorListAST::Node m_initDeclaratorList;
01001 
01002 private:
01003     TypedefAST( const TypedefAST& source );
01004     void operator = ( const TypedefAST& source );
01005 };
01006 
01007 class TemplateParameterAST: public AST
01008 {
01009 public:
01010     typedef AUTO_PTR<TemplateParameterAST> Node;
01011     enum { Type = NodeType_TemplateParameter };
01012 
01013     DECLARE_ALLOC( TemplateParameterAST )
01014     
01015 public:
01016     TemplateParameterAST();
01017 
01018     TypeParameterAST* typeParameter() { return m_typeParameter.get(); }
01019     void setTypeParameter( TypeParameterAST::Node& typeParameter );
01020 
01021     ParameterDeclarationAST* typeValueParameter() { return m_typeValueParameter.get(); }
01022     void setTypeValueParameter( ParameterDeclarationAST::Node& typeValueParameter );
01023 
01024 private:
01025     TypeParameterAST::Node m_typeParameter;
01026     ParameterDeclarationAST::Node m_typeValueParameter;
01027 
01028 private:
01029     TemplateParameterAST( const TemplateParameterAST& source );
01030     void operator = ( const TemplateParameterAST& source );
01031 };
01032 
01033 class TemplateParameterListAST: public AST
01034 {
01035 public:
01036     typedef AUTO_PTR<TemplateParameterListAST> Node;
01037     enum { Type = NodeType_TemplateParameterList };
01038 
01039     DECLARE_ALLOC( TemplateParameterListAST )
01040     
01041 public:
01042     TemplateParameterListAST();
01043 
01044     QPtrList<TemplateParameterAST> templateParameterList() { return m_templateParameterList; }
01045     void addTemplateParameter( TemplateParameterAST::Node& templateParameter );
01046 
01047 private:
01048     QPtrList<TemplateParameterAST> m_templateParameterList;
01049 
01050 private:
01051     TemplateParameterListAST( const TemplateParameterListAST& source );
01052     void operator = ( const TemplateParameterListAST& source );
01053 };
01054 
01055 class TemplateDeclarationAST: public DeclarationAST
01056 {
01057 public:
01058     typedef AUTO_PTR<TemplateDeclarationAST> Node;
01059     enum { Type = NodeType_TemplateDeclaration };
01060 
01061     DECLARE_ALLOC( TemplateDeclarationAST )
01062     
01063 public:
01064     TemplateDeclarationAST();
01065 
01066     AST* exported() { return m_exported.get(); }
01067     void setExported( AST::Node& exported );
01068 
01069     TemplateParameterListAST* templateParameterList() { return m_templateParameterList.get(); }
01070     void setTemplateParameterList( TemplateParameterListAST::Node& templateParameterList );
01071 
01072     DeclarationAST* declaration() { return m_declaration.get(); }
01073     void setDeclaration( DeclarationAST::Node& declaration );
01074 
01075 private:
01076     AST::Node m_exported;
01077     TemplateParameterListAST::Node m_templateParameterList;
01078     DeclarationAST::Node m_declaration;
01079 
01080 private:
01081     TemplateDeclarationAST( const TemplateDeclarationAST& source );
01082     void operator = ( const TemplateDeclarationAST& source );
01083 };
01084 
01085 class SimpleDeclarationAST: public DeclarationAST
01086 {
01087 public:
01088     typedef AUTO_PTR<SimpleDeclarationAST> Node;
01089     enum { Type = NodeType_SimpleDeclaration };
01090 
01091     DECLARE_ALLOC( SimpleDeclarationAST )
01092     
01093 public:
01094     SimpleDeclarationAST();
01095 
01096     GroupAST* functionSpecifier() { return m_functionSpecifier.get(); }
01097     void setFunctionSpecifier( GroupAST::Node& functionSpecifier );
01098 
01099     GroupAST* storageSpecifier() { return m_storageSpecifier.get(); }
01100     void setStorageSpecifier( GroupAST::Node& storageSpecifier );
01101 
01102     TypeSpecifierAST* typeSpec() { return m_typeSpec.get(); }
01103     void setTypeSpec( TypeSpecifierAST::Node& typeSpec );
01104 
01105     InitDeclaratorListAST* initDeclaratorList() { return m_initDeclaratorList.get(); }
01106     void setInitDeclaratorList( InitDeclaratorListAST::Node& initDeclaratorList );
01107 
01108     GroupAST* winDeclSpec() { return m_winDeclSpec.get(); }
01109     void setWinDeclSpec( GroupAST::Node& winDeclSpec );
01110 
01111 private:
01112     GroupAST::Node m_functionSpecifier;
01113     GroupAST::Node m_storageSpecifier;
01114     TypeSpecifierAST::Node m_typeSpec;
01115     InitDeclaratorListAST::Node m_initDeclaratorList;
01116     GroupAST::Node m_winDeclSpec;
01117 
01118 private:
01119     SimpleDeclarationAST( const SimpleDeclarationAST& source );
01120     void operator = ( const SimpleDeclarationAST& source );
01121 };
01122 
01123 class StatementAST: public AST
01124 {
01125 public:
01126     typedef AUTO_PTR<StatementAST> Node;
01127     enum { Type = NodeType_Statement };
01128 
01129     DECLARE_ALLOC( StatementAST )
01130     
01131 public:
01132     StatementAST();
01133 
01134 private:
01135     StatementAST( const StatementAST& source );
01136     void operator = ( const StatementAST& source );
01137 };
01138 
01139 class ExpressionStatementAST: public StatementAST
01140 {
01141 public:
01142     typedef AUTO_PTR<ExpressionStatementAST> Node;
01143     enum { Type = NodeType_ExpressionStatement };
01144 
01145     DECLARE_ALLOC( ExpressionStatementAST )
01146     
01147 public:
01148     ExpressionStatementAST();
01149 
01150     AST* expression() { return m_expression.get(); }
01151     void setExpression( AST::Node& expression );
01152 
01153 private:
01154     AST::Node m_expression;
01155 
01156 private:
01157     ExpressionStatementAST( const ExpressionStatementAST& source );
01158     void operator = ( const ExpressionStatementAST& source );
01159 };
01160 
01161 class ConditionAST: public AST
01162 {
01163 public:
01164     typedef AUTO_PTR<ConditionAST> Node;
01165     enum { Type = NodeType_Condition };
01166 
01167     DECLARE_ALLOC( ConditionAST )
01168     
01169 public:
01170     ConditionAST();
01171 
01172     TypeSpecifierAST* typeSpec() { return m_typeSpec.get(); }
01173     void setTypeSpec( TypeSpecifierAST::Node& typeSpec );
01174 
01175     DeclaratorAST* declarator() { return m_declarator.get(); }
01176     void setDeclarator( DeclaratorAST::Node& declarator );
01177 
01178     AST* expression() { return m_expression.get(); }
01179     void setExpression( AST::Node& expression );
01180 
01181 private:
01182     TypeSpecifierAST::Node m_typeSpec;
01183     DeclaratorAST::Node m_declarator;
01184     AST::Node m_expression;
01185 
01186 private:
01187     ConditionAST( const ConditionAST& source );
01188     void operator = ( const ConditionAST& source );
01189 };
01190 
01191 class IfStatementAST: public StatementAST
01192 {
01193 public:
01194     typedef AUTO_PTR<IfStatementAST> Node;
01195     enum { Type = NodeType_IfStatement };
01196 
01197     DECLARE_ALLOC( IfStatementAST )
01198     
01199 public:
01200     IfStatementAST();
01201 
01202     ConditionAST* condition() const { return m_condition.get(); }
01203     void setCondition( ConditionAST::Node& condition );
01204 
01205     StatementAST* statement() { return m_statement.get(); }
01206     void setStatement( StatementAST::Node& statement );
01207 
01208     StatementAST* elseStatement() { return m_elseStatement.get(); }
01209     void setElseStatement( StatementAST::Node& statement );
01210 
01211 private:
01212     ConditionAST::Node m_condition;
01213     StatementAST::Node m_statement;
01214     StatementAST::Node m_elseStatement;
01215 
01216 private:
01217     IfStatementAST( const IfStatementAST& source );
01218     void operator = ( const IfStatementAST& source );
01219 };
01220 
01221 class WhileStatementAST: public StatementAST
01222 {
01223 public:
01224     typedef AUTO_PTR<WhileStatementAST> Node;
01225     enum { Type = NodeType_WhileStatement };
01226 
01227     DECLARE_ALLOC( WhileStatementAST )
01228     
01229 public:
01230     WhileStatementAST();
01231 
01232     ConditionAST* condition() const { return m_condition.get(); }
01233     void setCondition( ConditionAST::Node& condition );
01234 
01235     StatementAST* statement() { return m_statement.get(); }
01236     void setStatement( StatementAST::Node& statement );
01237 
01238 private:
01239     ConditionAST::Node m_condition;
01240     StatementAST::Node m_statement;
01241 
01242 private:
01243     WhileStatementAST( const WhileStatementAST& source );
01244     void operator = ( const WhileStatementAST& source );
01245 };
01246 
01247 class DoStatementAST: public StatementAST
01248 {
01249 public:
01250     typedef AUTO_PTR<DoStatementAST> Node;
01251     enum { Type = NodeType_DoStatement };
01252 
01253     DECLARE_ALLOC( DoStatementAST )
01254     
01255 public:
01256     DoStatementAST();
01257 
01258     ConditionAST* condition() const { return m_condition.get(); }
01259     void setCondition( ConditionAST::Node& condition );
01260 
01261     StatementAST* statement() { return m_statement.get(); }
01262     void setStatement( StatementAST::Node& statement );
01263 
01264 private:
01265     ConditionAST::Node m_condition;
01266     StatementAST::Node m_statement;
01267 
01268 private:
01269     DoStatementAST( const DoStatementAST& source );
01270     void operator = ( const DoStatementAST& source );
01271 };
01272 
01273 class ForStatementAST: public StatementAST
01274 {
01275 public:
01276     typedef AUTO_PTR<ForStatementAST> Node;
01277     enum { Type = NodeType_ForStatement };
01278 
01279     DECLARE_ALLOC( ForStatementAST )
01280     
01281 public:
01282     ForStatementAST();
01283 
01284     StatementAST* initStatement() { return m_initStatement.get(); }
01285     void setInitStatement( StatementAST::Node& statement );
01286 
01287     ConditionAST* condition() const { return m_condition.get(); }
01288     void setCondition( ConditionAST::Node& condition );
01289 
01290     AST* expression() const { return m_expression.get(); }
01291     void setExpression( AST::Node& expression );
01292 
01293     StatementAST* statement() { return m_statement.get(); }
01294     void setStatement( StatementAST::Node& statement );
01295 
01296 private:
01297     ConditionAST::Node m_condition;
01298     StatementAST::Node m_initStatement;
01299     StatementAST::Node m_statement;
01300     AST::Node m_expression;
01301 
01302 private:
01303     ForStatementAST( const ForStatementAST& source );
01304     void operator = ( const ForStatementAST& source );
01305 };
01306 
01307 class SwitchStatementAST: public StatementAST
01308 {
01309 public:
01310     typedef AUTO_PTR<SwitchStatementAST> Node;
01311     enum { Type = NodeType_SwitchStatement };
01312 
01313     DECLARE_ALLOC( SwitchStatementAST )
01314     
01315 public:
01316     SwitchStatementAST();
01317 
01318     ConditionAST* condition() const { return m_condition.get(); }
01319     void setCondition( ConditionAST::Node& condition );
01320 
01321     StatementAST* statement() { return m_statement.get(); }
01322     void setStatement( StatementAST::Node& statement );
01323 
01324 private:
01325     ConditionAST::Node m_condition;
01326     StatementAST::Node m_statement;
01327 
01328 private:
01329     SwitchStatementAST( const SwitchStatementAST& source );
01330     void operator = ( const SwitchStatementAST& source );
01331 };
01332 
01333 class StatementListAST: public StatementAST
01334 {
01335 public:
01336     typedef AUTO_PTR<StatementListAST> Node;
01337     enum { Type = NodeType_StatementList };
01338 
01339     DECLARE_ALLOC( StatementListAST )
01340     
01341 public:
01342     StatementListAST();
01343 
01344     QPtrList<StatementAST> statementList() { return m_statementList; }
01345     void addStatement( StatementAST::Node& statement );
01346 
01347 private:
01348     QPtrList<StatementAST> m_statementList;
01349 
01350 private:
01351     StatementListAST( const StatementListAST& source );
01352     void operator = ( const StatementListAST& source );
01353 };
01354 
01355 class DeclarationStatementAST: public StatementAST
01356 {
01357 public:
01358     typedef AUTO_PTR<DeclarationStatementAST> Node;
01359     enum { Type = NodeType_DeclarationStatement };
01360 
01361     DECLARE_ALLOC( DeclarationStatementAST )
01362     
01363 public:
01364     DeclarationStatementAST();
01365 
01366     DeclarationAST* declaration() { return m_declaration.get(); }
01367     void setDeclaration( DeclarationAST::Node& declaration );
01368 
01369 private:
01370     DeclarationAST::Node m_declaration;
01371 
01372 private:
01373     DeclarationStatementAST( const DeclarationStatementAST& source );
01374     void operator = ( const DeclarationStatementAST& source );
01375 };
01376 
01377 class FunctionDefinitionAST: public DeclarationAST
01378 {
01379 public:
01380     typedef AUTO_PTR<FunctionDefinitionAST> Node;
01381     enum { Type = NodeType_FunctionDefinition };
01382 
01383     DECLARE_ALLOC( FunctionDefinitionAST )
01384     
01385 public:
01386     FunctionDefinitionAST();
01387 
01388     GroupAST* functionSpecifier() { return m_functionSpecifier.get(); }
01389     void setFunctionSpecifier( GroupAST::Node& functionSpecifier );
01390 
01391     GroupAST* storageSpecifier() { return m_storageSpecifier.get(); }
01392     void setStorageSpecifier( GroupAST::Node& storageSpecifier );
01393 
01394     TypeSpecifierAST* typeSpec() { return m_typeSpec.get(); }
01395     void setTypeSpec( TypeSpecifierAST::Node& typeSpec );
01396 
01397     InitDeclaratorAST* initDeclarator() { return m_initDeclarator.get(); }
01398     void setInitDeclarator( InitDeclaratorAST::Node& initDeclarator );
01399 
01400     StatementListAST* functionBody() { return m_functionBody.get(); }
01401     void setFunctionBody( StatementListAST::Node& functionBody );
01402 
01403     GroupAST* winDeclSpec() { return m_winDeclSpec.get(); }
01404     void setWinDeclSpec( GroupAST::Node& winDeclSpec );
01405 
01406 private:
01407     GroupAST::Node m_functionSpecifier;
01408     GroupAST::Node m_storageSpecifier;
01409     TypeSpecifierAST::Node m_typeSpec;
01410     InitDeclaratorAST::Node m_initDeclarator;
01411     StatementListAST::Node m_functionBody;
01412     GroupAST::Node m_winDeclSpec;
01413 
01414 private:
01415     FunctionDefinitionAST( const FunctionDefinitionAST& source );
01416     void operator = ( const FunctionDefinitionAST& source );
01417 };
01418 
01419 
01420 class TranslationUnitAST: public AST
01421 {
01422 public:
01423     typedef AUTO_PTR<TranslationUnitAST> Node;
01424     enum { Type = NodeType_TranslationUnit };
01425 
01426     DECLARE_ALLOC( TranslationUnitAST )
01427     
01428 public:
01429     TranslationUnitAST();
01430 
01431     void addDeclaration( DeclarationAST::Node& ast );
01432     QPtrList<DeclarationAST> declarationList() { return m_declarationList; }
01433 
01434 private:
01435     QPtrList<DeclarationAST> m_declarationList;
01436 
01437 private:
01438     TranslationUnitAST( const TranslationUnitAST& source );
01439     void operator = ( const TranslationUnitAST& source );
01440 };
01441 
01442 #endif
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Feb 22 09:22:35 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003