Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1262 insertions, 0 deletions

diff --git a/lib/cppparser/ast.cpp b/lib/cppparser/ast.cpp
new file mode 100644
index 00000000..b6f452c0
--- /dev/null
+++ b/lib/cppparser/ast.cpp
@@ -0,0 +1,1262 @@
+/* This file is part of KDevelop
+    Copyright (C) 2002,2003 Roberto Raggi <roberto@kdevelop.org>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+#include "ast.h"
+#include <qstringlist.h>
+#include <kdebug.h>
+
+QString nodeTypeToString( int type )
+{
+    switch( type )
+    {
+    case NodeType_Generic:
+	return "Generic";
+    case NodeType_TemplateArgumentList:
+	return "TemplateArgumentList";
+    case NodeType_ClassOrNamespaceName:
+	return "ClassOrNamespaceName";
+    case NodeType_Name:
+	return "Name";
+    case NodeType_Declaration:
+	return "Declaration";
+    case NodeType_TypeSpecifier:
+	return "TypeSpecifier";
+    case NodeType_BaseSpecifier:
+	return "BaseSpecifier";
+    case NodeType_BaseClause:
+	return "BaseClause";
+    case NodeType_ClassSpecifier:
+	return "ClassSpecifier";
+    case NodeType_Enumerator:
+	return "Enumerator";
+    case NodeType_EnumSpecifier:
+	return "EnumSpecifier";
+    case NodeType_ElaboratedTypeSpecifier:
+	return "ElaboratedTypeSpecifier";
+    case NodeType_LinkageBody:
+	return "LinkageBody";
+    case NodeType_LinkageSpecification:
+	return "LinkageSpecification";
+    case NodeType_Namespace:
+	return "Namespace";
+    case NodeType_NamespaceAlias:
+	return "NamespaceAlias";
+    case NodeType_Using:
+	return "Using";
+    case NodeType_UsingDirective:
+	return "UsingDirective";
+    case NodeType_InitDeclaratorList:
+	return "InitDeclaratorList";
+    case NodeType_Typedef:
+	return "Typedef";
+    case NodeType_Declarator:
+	return "Declarator";
+    case NodeType_InitDeclarator:
+	return "InitDeclarator";
+    case NodeType_TemplateDeclaration:
+	return "TemplateDeclaration";
+    case NodeType_SimpleDeclaration:
+	return "SimpleDeclaration";
+    case NodeType_Statement:
+	return "Statement";
+    case NodeType_IfStatement:
+	return "IfStatement";
+    case NodeType_WhileStatement:
+	return "WhileStatement";
+    case NodeType_DoStatement:
+	return "DoStatement";
+    case NodeType_ForStatement:
+	return "ForStatement";
+    case NodeType_ForEachStatement: // qt4 [erbsland]
+	return "ForEachStatement";
+    case NodeType_SwitchStatement:
+	return "SwitchStatement";
+    case NodeType_CatchStatement:
+	return "CatchStatement";
+    case NodeType_CatchStatementList:
+	return "CatchStatementList";
+    case NodeType_TryBlockStatement:
+	return "TryBlockStatement";
+    case NodeType_DeclarationStatement:
+	return "DeclarationStatement";
+    case NodeType_StatementList:
+	return "StatementList";
+    case NodeType_TranslationUnit:
+	return "TranslationUnit";
+    case NodeType_FunctionDefinition:
+	return "FunctionDefinition";
+    case NodeType_ExpressionStatement:
+	return "ExpressionStatement";
+    case NodeType_ParameterDeclaration:
+	return "ParameterDeclaration";
+    case NodeType_ParameterDeclarationList:
+	return "ParameterDeclarationList";
+    case NodeType_ParameterDeclarationClause:
+	return "ParameterDeclarationClause";
+    case NodeType_Group:
+	return "Group";
+    case NodeType_AccessDeclaration:
+	return "AccessDeclaration";
+    case NodeType_TypeParameter:
+	return "TypeParameter";
+    case NodeType_TemplateParameter:
+	return "TemplateParameter";
+    case NodeType_TemplateParameterList:
+	return "TemplateParameterList";
+    case NodeType_Condition:
+	return "Condition";
+    case NodeType_Custom:
+	return "Custom";
+    }
+
+    return QString::null;
+}
+
+
+// ------------------------------------------------------------------------
+AST::AST()
+    : m_nodeType( NodeType_Generic ), m_parent( 0 ),
+      m_startLine( 0 ), m_startColumn( 0 ),
+      m_endLine( 0 ), m_endColumn( 0 )
+{
+#ifndef CPPPARSER_NO_CHILDREN
+    m_children.setAutoDelete( false );
+#endif
+}
+
+AST::~AST()
+{
+#ifndef CPPPARSER_NO_CHILDREN
+    if( m_parent )
+	m_parent->removeChild( this );
+#endif
+}
+
+void AST::setStartPosition( int line, int col )
+{
+   m_startLine = line;
+   m_startColumn = col;
+}
+
+void AST::getStartPosition( int* line, int* col ) const
+{
+    if( line )
+        *line = m_startLine;
+
+    if( col )
+        * col = m_startColumn;
+}
+
+void AST::setEndPosition( int line, int col )
+{
+   m_endLine = line;
+   m_endColumn = col;
+}
+
+void AST::getEndPosition( int* line, int* col ) const
+{
+    if( line )
+        *line = m_endLine;
+
+    if( col )
+        * col = m_endColumn;
+}
+
+void AST::setParent( AST* parent )
+{
+#ifndef CPPPARSER_NO_CHILDREN
+    if( m_parent )
+	m_parent->removeChild( this );
+#endif
+
+    m_parent = parent;
+
+#ifndef CPPPARSER_NO_CHILDREN
+    if( m_parent )
+	m_parent->appendChild( this );
+#endif
+}
+
+#ifndef CPPPARSER_NO_CHILDREN
+void AST::appendChild( AST* child )
+{
+    m_children.append( child );
+}
+
+void AST::removeChild( AST* child )
+{
+    m_children.remove( child );
+}
+#endif
+
+// ------------------------------------------------------------------------
+NameAST::NameAST()
+    : m_global( false )
+{
+    m_classOrNamespaceNameList.setAutoDelete( true );
+}
+
+void NameAST::setGlobal( bool b )
+{
+    m_global = b;
+}
+
+void NameAST::setUnqualifiedName( ClassOrNamespaceNameAST::Node& unqualifiedName )
+{
+    m_unqualifiedName = unqualifiedName;
+    if( m_unqualifiedName.get() ) m_unqualifiedName->setParent( this );
+}
+
+void NameAST::addClassOrNamespaceName( ClassOrNamespaceNameAST::Node& classOrNamespaceName )
+{
+    if( !classOrNamespaceName.get() )
+        return;
+
+    classOrNamespaceName->setParent( this );
+    m_classOrNamespaceNameList.append( classOrNamespaceName.release() );
+}
+
+QString NameAST::text() const
+{
+    if( !m_unqualifiedName.get() )
+        return QString::null;
+
+    QString str;
+
+    if( m_global )
+        str += "::";
+
+    QStringList l;
+    QPtrListIterator<ClassOrNamespaceNameAST> it( m_classOrNamespaceNameList );
+    while( it.current() ){
+        str += it.current()->text() + "::";
+        ++it;
+    }
+
+    if( m_unqualifiedName.get() )
+	str += m_unqualifiedName->text();
+
+    return str;
+}
+
+// ------------------------------------------------------------------------
+DeclarationAST::DeclarationAST()
+{
+}
+
+// ------------------------------------------------------------------------
+LinkageBodyAST::LinkageBodyAST()
+{
+    m_declarationList.setAutoDelete( true );
+}
+
+void LinkageBodyAST::addDeclaration( DeclarationAST::Node& ast )
+{
+    if( !ast.get() )
+        return;
+
+    ast->setParent( this );
+    m_declarationList.append( ast.release() );
+}
+
+// ------------------------------------------------------------------------
+LinkageSpecificationAST::LinkageSpecificationAST()
+{
+}
+
+void LinkageSpecificationAST::setExternType( AST::Node& externType )
+{
+    m_externType = externType;
+    if( m_externType.get() ) m_externType->setParent( this );
+}
+
+void LinkageSpecificationAST::setLinkageBody( LinkageBodyAST::Node& linkageBody )
+{
+    m_linkageBody = linkageBody;
+    if( m_linkageBody.get() ) m_linkageBody->setParent( this );
+}
+
+void LinkageSpecificationAST::setDeclaration( DeclarationAST::Node& decl )
+{
+    m_declaration = decl;
+    if( m_declaration.get() ) m_declaration->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+TranslationUnitAST::TranslationUnitAST()
+{
+    ////kdDebug(9007) << "++ TranslationUnitAST::TranslationUnitAST()" << endl;
+    m_declarationList.setAutoDelete( true );
+}
+
+void TranslationUnitAST::addDeclaration( DeclarationAST::Node& ast )
+{
+    if( !ast.get() )
+        return;
+
+    ast->setParent( this );
+    m_declarationList.append( ast.release() );
+}
+
+// ------------------------------------------------------------------------
+NamespaceAST::NamespaceAST()
+{
+}
+
+void NamespaceAST::setNamespaceName( AST::Node& namespaceName )
+{
+    m_namespaceName = namespaceName;
+    if( m_namespaceName.get() ) m_namespaceName->setParent( this );
+}
+
+void NamespaceAST::setLinkageBody( LinkageBodyAST::Node& linkageBody )
+{
+    m_linkageBody = linkageBody;
+    if( m_linkageBody.get() ) m_linkageBody->setParent( this );
+}
+
+
+// ------------------------------------------------------------------------
+NamespaceAliasAST::NamespaceAliasAST()
+{
+}
+
+void NamespaceAliasAST::setNamespaceName( AST::Node& namespaceName )
+{
+    m_namespaceName = namespaceName;
+    if( m_namespaceName.get() ) m_namespaceName->setParent( this );
+}
+
+void NamespaceAliasAST::setAliasName( NameAST::Node& name )
+{
+    m_aliasName = name;
+    if( m_aliasName.get() ) m_aliasName->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+UsingAST::UsingAST()
+{
+}
+
+void UsingAST::setTypeName( AST::Node& typeName )
+{
+    m_typeName = typeName;
+    if( m_typeName.get() ) m_typeName->setParent( this );
+}
+
+void UsingAST::setName( NameAST::Node& name )
+{
+    m_name = name;
+    if( m_name.get() ) m_name->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+UsingDirectiveAST::UsingDirectiveAST()
+{
+}
+
+void UsingDirectiveAST::setName( NameAST::Node& name )
+{
+    m_name = name;
+    if( m_name.get() ) m_name->setParent( this );
+}
+
+TypedefAST::TypedefAST()
+{
+}
+
+void TypeSpecifierAST::setName( NameAST::Node& name )
+{
+    m_name = name;
+    if( m_name.get() ) m_name->setParent( this );
+}
+
+void TypedefAST::setTypeSpec( TypeSpecifierAST::Node& typeSpec )
+{
+    m_typeSpec = typeSpec;
+    if( m_typeSpec.get() ) m_typeSpec->setParent( this );
+}
+
+void TypedefAST::setInitDeclaratorList( InitDeclaratorListAST::Node& initDeclaratorList )
+{
+    m_initDeclaratorList = initDeclaratorList;
+    if( m_initDeclaratorList.get() ) m_initDeclaratorList->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+TemplateArgumentListAST::TemplateArgumentListAST()
+{
+    m_argumentList.setAutoDelete( true );
+}
+
+void TemplateArgumentListAST::addArgument( AST::Node& arg )
+{
+    if( !arg.get() )
+        return;
+
+    arg->setParent( this );
+    m_argumentList.append( arg.release() );
+}
+
+QString TemplateArgumentListAST::text() const
+{
+    QStringList l;
+
+    QPtrListIterator<AST> it( m_argumentList );
+    while( it.current() ){
+        l.append( it.current()->text() );
+	++it;
+    }
+
+    return l.join( ", " );
+}
+
+// ------------------------------------------------------------------------
+TemplateDeclarationAST::TemplateDeclarationAST()
+{
+}
+
+void TemplateDeclarationAST::setExported( AST::Node& exported )
+{
+    m_exported = exported;
+    if( m_exported.get() ) m_exported->setParent( this );
+}
+
+void TemplateDeclarationAST::setTemplateParameterList( TemplateParameterListAST::Node& templateParameterList )
+{
+    m_templateParameterList = templateParameterList;
+    if( m_templateParameterList.get() ) m_templateParameterList->setParent( this );
+}
+
+void TemplateDeclarationAST::setDeclaration( DeclarationAST::Node& declaration )
+{
+    m_declaration = declaration;
+    if( m_declaration.get() ) m_declaration->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+ClassOrNamespaceNameAST::ClassOrNamespaceNameAST()
+{
+}
+
+void ClassOrNamespaceNameAST::setName( AST::Node& name )
+{
+    m_name = name;
+    if( m_name.get() ) m_name->setParent( this );
+}
+
+void ClassOrNamespaceNameAST::setTemplateArgumentList( TemplateArgumentListAST::Node& templateArgumentList )
+{
+    m_templateArgumentList = templateArgumentList;
+    if( m_templateArgumentList.get() ) m_templateArgumentList->setParent( this );
+}
+
+QString ClassOrNamespaceNameAST::text() const
+{
+    if( !m_name.get() )
+        return QString::null;
+
+    QString str = m_name->text();
+    if( m_templateArgumentList.get() )
+        str += QString::fromLatin1("< ") + m_templateArgumentList->text() + QString::fromLatin1(" >");
+
+    return str;
+}
+
+// ------------------------------------------------------------------------
+TypeSpecifierAST::TypeSpecifierAST()
+{
+}
+
+void TypeSpecifierAST::setCvQualify( GroupAST::Node& cvQualify )
+{
+    m_cvQualify = cvQualify;
+    if( m_cvQualify.get() ) m_cvQualify->setParent( this );
+}
+
+void TypeSpecifierAST::setCv2Qualify( GroupAST::Node& cv2Qualify )
+{
+    m_cv2Qualify = cv2Qualify;
+    if( m_cv2Qualify.get() ) m_cv2Qualify->setParent( this );
+}
+
+QString TypeSpecifierAST::text() const
+{
+    QString str;
+
+    if( m_cvQualify.get() )
+        str += m_cvQualify->text() + " ";
+
+    if( m_name.get() )
+        str += m_name->text();
+
+    if( m_cv2Qualify.get() )
+        str += QString(" ") + m_cv2Qualify->text();
+
+    return str;
+}
+
+// ------------------------------------------------------------------------
+ClassSpecifierAST::ClassSpecifierAST()
+{
+    m_declarationList.setAutoDelete( true );
+}
+
+void ClassSpecifierAST::setClassKey( AST::Node& classKey )
+{
+    m_classKey = classKey;
+    if( m_classKey.get() ) m_classKey->setParent( this );
+}
+
+void ClassSpecifierAST::addDeclaration( DeclarationAST::Node& declaration )
+{
+    if( !declaration.get() )
+        return;
+
+    declaration->setParent( this );
+    m_declarationList.append( declaration.release() );
+}
+
+void ClassSpecifierAST::setBaseClause( BaseClauseAST::Node& baseClause )
+{
+    m_baseClause = baseClause;
+    if( m_baseClause.get() ) m_baseClause->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+EnumSpecifierAST::EnumSpecifierAST()
+{
+    m_enumeratorList.setAutoDelete( true );
+}
+
+void EnumSpecifierAST::addEnumerator( EnumeratorAST::Node& enumerator )
+{
+    if( !enumerator.get() )
+        return;
+
+    enumerator->setParent( this );
+    m_enumeratorList.append( enumerator.release() );
+}
+
+
+// ------------------------------------------------------------------------
+ElaboratedTypeSpecifierAST::ElaboratedTypeSpecifierAST()
+{
+}
+
+void ElaboratedTypeSpecifierAST::setKind( AST::Node& kind )
+{
+    m_kind = kind;
+    if( m_kind.get() ) m_kind->setParent( this );
+}
+
+QString ElaboratedTypeSpecifierAST::text() const
+{
+    if( m_kind.get() )
+        return m_kind->text() + " " + TypeSpecifierAST::text();
+
+    return TypeSpecifierAST::text();
+}
+
+// ------------------------------------------------------------------------
+StatementAST::StatementAST()
+{
+}
+
+// ------------------------------------------------------------------------
+EnumeratorAST::EnumeratorAST()
+{
+}
+
+void EnumeratorAST::setId( AST::Node& id )
+{
+    m_id = id;
+    if( m_id.get() ) m_id->setParent( this );
+}
+
+void EnumeratorAST::setExpr( AST::Node& expr )
+{
+    m_expr = expr;
+    if( m_expr.get() ) m_expr->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+BaseClauseAST::BaseClauseAST()
+{
+    m_baseSpecifierList.setAutoDelete( true );
+}
+
+void BaseClauseAST::addBaseSpecifier( BaseSpecifierAST::Node& baseSpecifier )
+{
+    if( !baseSpecifier.get() )
+        return;
+
+    baseSpecifier->setParent( this );
+    m_baseSpecifierList.append( baseSpecifier.release() );
+}
+
+// ------------------------------------------------------------------------
+BaseSpecifierAST::BaseSpecifierAST()
+{
+}
+
+void BaseSpecifierAST::setIsVirtual( AST::Node& isVirtual )
+{
+    m_isVirtual = isVirtual;
+    if( m_isVirtual.get() ) m_isVirtual->setParent( this );
+}
+
+void BaseSpecifierAST::setAccess( AST::Node& access )
+{
+    m_access = access;
+    if( m_access.get() ) m_access->setParent( this );
+}
+
+void BaseSpecifierAST::setName( NameAST::Node& name )
+{
+    m_name = name;
+    if( m_name.get() ) m_name->setParent( this );
+}
+
+// ------------------------------------------------------------------------
+SimpleDeclarationAST::SimpleDeclarationAST()
+{
+}
+
+void SimpleDeclarationAST::setFunctionSpecifier( GroupAST::Node& functionSpecifier )
+{
+    m_functionSpecifier = functionSpecifier;
+    if( m_functionSpecifier.get() ) m_functionSpecifier->setParent( this );
+}
+
+void SimpleDeclarationAST::setStorageSpecifier( GroupAST::Node& storageSpecifier )
+{
+    m_storageSpecifier = storageSpecifier;
+    if( m_storageSpecifier.get() ) m_storageSpecifier->setParent( this );
+}
+
+void SimpleDeclarationAST::setTypeSpec( TypeSpecifierAST::Node& typeSpec )
+{
+    m_typeSpec = typeSpec;
+    if( m_typeSpec.get() ) m_typeSpec->setParent( this );
+}
+
+void SimpleDeclarationAST::setInitDeclaratorList( InitDeclaratorListAST::Node& initDeclaratorList )
+{
+    m_initDeclaratorList = initDeclaratorList;
+    if( m_initDeclaratorList.get() ) m_initDeclaratorList->setParent( this );
+}
+
+void SimpleDeclarationAST::setWinDeclSpec( GroupAST::Node& winDeclSpec )
+{
+    m_winDeclSpec = winDeclSpec;
+    if( m_winDeclSpec.get() ) m_winDeclSpec->setParent( this );
+}
+
+
+// ------------------------------------------------------------------------
+InitDeclaratorListAST::InitDeclaratorListAST()
+{
+    m_initDeclaratorList.setAutoDelete( true );
+}
+
+void InitDeclaratorListAST::addInitDeclarator( InitDeclaratorAST::Node& decl )
+{
+    if( !decl.get() )
+	return;
+
+    decl->setParent( this );
+    m_initDeclaratorList.append( decl.release() );
+}
+
+// ------------------------------------------------------------------------
+DeclaratorAST::DeclaratorAST()
+{
+    m_ptrOpList.setAutoDelete( true );
+    m_arrayDimensionList.setAutoDelete( true );
+}
+
+void DeclaratorAST::setSubDeclarator( DeclaratorAST::Node& subDeclarator )
+{
+    m_subDeclarator = subDeclarator;
+    if( m_subDeclarator.get() ) m_subDeclarator->setParent( this );
+}
+
+void DeclaratorAST::setDeclaratorId( NameAST::Node& declaratorId )
+{
+    m_declaratorId = declaratorId;
+    if( m_declaratorId.get() ) m_declaratorId->setParent( this );
+}
+
+void DeclaratorAST::setBitfieldInitialization( AST::Node& bitfieldInitialization )
+{
+    m_bitfieldInitialization = bitfieldInitialization;
+    if( m_bitfieldInitialization.get() ) m_bitfieldInitialization->setParent( this );
+}
+
+void DeclaratorAST::addArrayDimension( AST::Node& arrayDimension )
+{
+    if( !arrayDimension.get() )
+        return;
+
+    arrayDimension->setParent( this );
+    m_arrayDimensionList.append( arrayDimension.release() );
+}
+
+void DeclaratorAST::setParameterDeclarationClause( ParameterDeclarationClauseAST::Node& parameterDeclarationClause )
+{
+    m_parameterDeclarationClause = parameterDeclarationClause;
+    if( m_parameterDeclarationClause.get() ) m_parameterDeclarationClause->setParent( this );
+}
+
+void DeclaratorAST::setConstant( AST::Node& constant )
+{
+    m_constant = constant;
+    if( m_constant.get() ) m_constant->setParent( this );
+}
+
+void DeclaratorAST::setExceptionSpecification( GroupAST::Node& exceptionSpecification )
+{
+    m_exceptionSpecification = exceptionSpecification;
+    if( m_exceptionSpecification.get() ) m_exceptionSpecification->setParent( this );
+}
+
+void DeclaratorAST::addPtrOp( AST::Node& ptrOp )
+{
+    if( !ptrOp.get() )
+        return;
+
+    ptrOp->setParent( this );
+    m_ptrOpList.append( ptrOp.release() );
+}
+
+// --------------------------------------------------------------------------
+InitDeclaratorAST::InitDeclaratorAST()
+{
+}
+
+void InitDeclaratorAST::setDeclarator( DeclaratorAST::Node& declarator )
+{
+    m_declarator = declarator;
+    if( m_declarator.get() ) m_declarator->setParent( this );
+}
+
+void InitDeclaratorAST::setInitializer( AST::Node& initializer )
+{
+    m_initializer = initializer;
+    if( m_initializer.get() ) m_initializer->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+FunctionDefinitionAST::FunctionDefinitionAST()
+{
+}
+
+void FunctionDefinitionAST::setFunctionSpecifier( GroupAST::Node& functionSpecifier )
+{
+    m_functionSpecifier = functionSpecifier;
+    if( m_functionSpecifier.get() ) m_functionSpecifier->setParent( this );
+}
+
+void FunctionDefinitionAST::setStorageSpecifier( GroupAST::Node& storageSpecifier )
+{
+    m_storageSpecifier = storageSpecifier;
+    if( m_storageSpecifier.get() ) m_storageSpecifier->setParent( this );
+}
+
+void FunctionDefinitionAST::setTypeSpec( TypeSpecifierAST::Node& typeSpec )
+{
+    m_typeSpec = typeSpec;
+    if( m_typeSpec.get() ) m_typeSpec->setParent( this );
+}
+
+void FunctionDefinitionAST::setInitDeclarator( InitDeclaratorAST::Node& initDeclarator )
+{
+    m_initDeclarator = initDeclarator;
+    if( m_initDeclarator.get() ) m_initDeclarator->setParent( this );
+}
+
+void FunctionDefinitionAST::setFunctionBody( StatementListAST::Node& functionBody )
+{
+    m_functionBody = functionBody;
+    if( m_functionBody.get() ) m_functionBody->setParent( this );
+}
+
+void FunctionDefinitionAST::setWinDeclSpec( GroupAST::Node& winDeclSpec )
+{
+    m_winDeclSpec = winDeclSpec;
+    if( m_winDeclSpec.get() ) m_winDeclSpec->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+StatementListAST::StatementListAST()
+{
+    m_statementList.setAutoDelete( true );
+}
+
+void StatementListAST::addStatement( StatementAST::Node& statement )
+{
+    if( !statement.get() )
+	return;
+
+    statement->setParent( this );
+    m_statementList.append( statement.release() );
+}
+
+// --------------------------------------------------------------------------
+IfStatementAST::IfStatementAST()
+{
+}
+
+void IfStatementAST::setCondition( ConditionAST::Node& condition )
+{
+    m_condition = condition;
+    if( m_condition.get() ) m_condition->setParent( this );
+}
+
+void IfStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+void IfStatementAST::setElseStatement( StatementAST::Node& elseStatement )
+{
+    m_elseStatement = elseStatement;
+    if( m_elseStatement.get() ) m_elseStatement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+WhileStatementAST::WhileStatementAST()
+{
+}
+
+void WhileStatementAST::setCondition( ConditionAST::Node& condition )
+{
+    m_condition = condition;
+    if( m_condition.get() ) m_condition->setParent( this );
+}
+
+void WhileStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+DoStatementAST::DoStatementAST()
+{
+}
+
+void DoStatementAST::setCondition( ConditionAST::Node& condition )
+{
+    m_condition = condition;
+    if( m_condition.get() ) m_condition->setParent( this );
+}
+
+void DoStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+ForStatementAST::ForStatementAST()
+{
+}
+
+void ForStatementAST::setCondition( ConditionAST::Node& condition )
+{
+    m_condition = condition;
+    if( m_condition.get() ) m_condition->setParent( this );
+}
+
+void ForStatementAST::setExpression( AST::Node& expression )
+{
+    m_expression = expression;
+    if( m_expression.get() ) m_expression->setParent( this );
+}
+
+void ForStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+void ForStatementAST::setInitStatement( StatementAST::Node& initStatement )
+{
+    m_initStatement = initStatement;
+    if( m_initStatement.get() ) m_initStatement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+ForEachStatementAST::ForEachStatementAST()
+{
+}
+
+void ForEachStatementAST::setExpression( AST::Node& expression )
+{
+    m_expression = expression;
+    if( m_expression.get() ) m_expression->setParent( this );
+}
+
+void ForEachStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+void ForEachStatementAST::setInitStatement( StatementAST::Node& initStatement )
+{
+    m_initStatement = initStatement;
+    if( m_initStatement.get() ) m_initStatement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+SwitchStatementAST::SwitchStatementAST()
+{
+}
+
+void SwitchStatementAST::setCondition( ConditionAST::Node& condition )
+{
+    m_condition = condition;
+    if( m_condition.get() ) m_condition->setParent( this );
+}
+
+void SwitchStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+CatchStatementListAST::CatchStatementListAST()
+{
+    m_statementList.setAutoDelete( true );
+}
+
+void CatchStatementListAST::addStatement( CatchStatementAST::Node& statement )
+{
+    if( !statement.get() )
+	return;
+
+    statement->setParent( this );
+    m_statementList.append( statement.release() );
+}
+
+// --------------------------------------------------------------------------
+CatchStatementAST::CatchStatementAST()
+{
+}
+
+void CatchStatementAST::setCondition( ConditionAST::Node& condition )
+{
+    m_condition = condition;
+    if( m_condition.get() ) m_condition->setParent( this );
+}
+
+void CatchStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+TryBlockStatementAST::TryBlockStatementAST()
+{
+}
+
+void TryBlockStatementAST::setStatement( StatementAST::Node& statement )
+{
+    m_statement = statement;
+    if( m_statement.get() ) m_statement->setParent( this );
+}
+
+void TryBlockStatementAST::setCatchStatementList( CatchStatementListAST::Node& statementList )
+{
+    m_catchStatementList = statementList;
+    if( m_catchStatementList.get() ) m_catchStatementList->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+DeclarationStatementAST::DeclarationStatementAST()
+{
+}
+
+void DeclarationStatementAST::setDeclaration( DeclarationAST::Node& declaration )
+{
+    m_declaration = declaration;
+    if( m_declaration.get() ) m_declaration->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+ExpressionStatementAST::ExpressionStatementAST()
+{
+}
+
+void ExpressionStatementAST::setExpression( AST::Node& expression )
+{
+    m_expression = expression;
+    if( m_expression.get() ) m_expression->setParent( this );
+}
+
+
+// --------------------------------------------------------------------------
+ParameterDeclarationAST::ParameterDeclarationAST()
+{
+}
+
+void ParameterDeclarationAST::setTypeSpec( TypeSpecifierAST::Node& typeSpec )
+{
+    m_typeSpec = typeSpec;
+    if( m_typeSpec.get() ) m_typeSpec->setParent( this );
+}
+
+void ParameterDeclarationAST::setDeclarator( DeclaratorAST::Node& declarator )
+{
+    m_declarator = declarator;
+    if( m_declarator.get() ) m_declarator->setParent( this );
+}
+
+void ParameterDeclarationAST::setExpression( AST::Node& expression )
+{
+    m_expression = expression;
+    if( m_expression.get() ) m_expression->setParent( this );
+}
+
+QString ParameterDeclarationAST::text() const
+{
+    QString str;
+    if( m_typeSpec.get() )
+        str += m_typeSpec->text() + " ";
+
+    if( m_declarator.get() )
+        str += m_declarator->text();
+
+    if( m_expression.get() )
+        str += QString( " = " ) + m_expression->text();
+
+    return str;
+}
+
+// --------------------------------------------------------------------------
+ParameterDeclarationListAST::ParameterDeclarationListAST()
+{
+    m_parameterList.setAutoDelete( true );
+}
+
+void ParameterDeclarationListAST::addParameter( ParameterDeclarationAST::Node& parameter )
+{
+    if( !parameter.get() )
+        return;
+
+    parameter->setParent( this );
+    m_parameterList.append( parameter.release() );
+}
+
+QString ParameterDeclarationListAST::text() const
+{
+    QStringList l;
+
+    QPtrListIterator<ParameterDeclarationAST> it( m_parameterList );
+    while( it.current() ){
+        l.append( it.current()->text() );
+	++it;
+    }
+
+    return l.join( ", " );
+}
+
+
+// --------------------------------------------------------------------------
+ParameterDeclarationClauseAST::ParameterDeclarationClauseAST()
+{
+}
+
+void ParameterDeclarationClauseAST::setParameterDeclarationList( ParameterDeclarationListAST::Node& parameterDeclarationList )
+{
+    m_parameterDeclarationList = parameterDeclarationList;
+    if( m_parameterDeclarationList.get() ) m_parameterDeclarationList->setParent( this );
+}
+
+void ParameterDeclarationClauseAST::setEllipsis( AST::Node& ellipsis )
+{
+    m_ellipsis = ellipsis;
+    if( m_ellipsis.get() ) m_ellipsis->setParent( this );
+}
+
+QString ParameterDeclarationClauseAST::text() const
+{
+    QString str;
+
+    if( m_parameterDeclarationList.get() )
+        str += m_parameterDeclarationList->text();
+
+    if( m_ellipsis.get() )
+        str += " ...";
+
+    return str;
+}
+
+
+// --------------------------------------------------------------------------
+GroupAST::GroupAST()
+{
+    m_nodeList.setAutoDelete( true );
+}
+
+void GroupAST::addNode( AST::Node& node )
+{
+    if( !node.get() )
+        return;
+
+    node->setParent( this );
+    m_nodeList.append( node.release() );
+}
+
+QString GroupAST::text() const
+{
+    QStringList l;
+
+    QPtrListIterator<AST> it( m_nodeList );
+    while( it.current() ){
+        l.append( it.current()->text() );
+	++it;
+    }
+
+    return l.join( " " );
+}
+
+// --------------------------------------------------------------------------
+AccessDeclarationAST::AccessDeclarationAST()
+{
+    m_accessList.setAutoDelete( true );
+}
+
+void AccessDeclarationAST::addAccess( AST::Node& access )
+{
+    if( !access.get() )
+        return;
+
+    access->setParent( this );
+    m_accessList.append( access.release() );
+}
+
+QString AccessDeclarationAST::text() const
+{
+    QStringList l;
+
+    QPtrListIterator<AST> it( m_accessList );
+    while( it.current() ){
+        l.append( it.current()->text() );
+	++it;
+    }
+
+    return l.join( " " );
+}
+
+// --------------------------------------------------------------------------
+TypeParameterAST::TypeParameterAST()
+{
+}
+
+void TypeParameterAST::setKind( AST::Node& kind )
+{
+    m_kind = kind;
+    if( m_kind.get() ) m_kind->setParent( this );
+}
+
+void TypeParameterAST::setTemplateParameterList( TemplateParameterListAST::Node& templateParameterList )
+{
+    m_templateParameterList = templateParameterList;
+    if( m_templateParameterList.get() ) m_templateParameterList->setParent( this );
+}
+
+void TypeParameterAST::setName( NameAST::Node& name )
+{
+    m_name = name;
+    if( m_name.get() ) m_name->setParent( this );
+}
+
+void TypeParameterAST::setTypeId( AST::Node& typeId )
+{
+    m_typeId = typeId;
+    if( m_typeId.get() ) m_typeId->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+TemplateParameterAST::TemplateParameterAST()
+{
+}
+
+void TemplateParameterAST::setTypeParameter( TypeParameterAST::Node& typeParameter )
+{
+    m_typeParameter = typeParameter;
+    if( m_typeParameter.get() ) m_typeParameter->setParent( this );
+}
+
+void TemplateParameterAST::setTypeValueParameter( ParameterDeclarationAST::Node& typeValueParameter )
+{
+    m_typeValueParameter = typeValueParameter;
+    if( m_typeValueParameter.get() ) m_typeValueParameter->setParent( this );
+}
+
+// --------------------------------------------------------------------------
+TemplateParameterListAST::TemplateParameterListAST()
+{
+    m_templateParameterList.setAutoDelete( true );
+}
+
+void TemplateParameterListAST::addTemplateParameter( TemplateParameterAST::Node& templateParameter )
+{
+    if( !templateParameter.get() )
+        return;
+
+    templateParameter->setParent( this );
+    m_templateParameterList.append( templateParameter.release() );
+}
+
+// --------------------------------------------------------------------------
+ConditionAST::ConditionAST()
+{
+}
+
+void ConditionAST::setTypeSpec( TypeSpecifierAST::Node& typeSpec )
+{
+    m_typeSpec = typeSpec;
+    if( m_typeSpec.get() ) m_typeSpec->setParent( this );
+}
+
+void ConditionAST::setDeclarator( DeclaratorAST::Node& declarator )
+{
+    m_declarator = declarator;
+    if( m_declarator.get() ) m_declarator->setParent( this );
+}
+
+void ConditionAST::setExpression( AST::Node& expression )
+{
+    m_expression = expression;
+    if( m_expression.get() ) m_expression->setParent( this );
+}
+
+void ClassSpecifierAST::setWinDeclSpec( GroupAST::Node & winDeclSpec )
+{
+    m_winDeclSpec = winDeclSpec;
+    if( m_winDeclSpec.get() ) m_winDeclSpec->setParent( this );
+}