KDevelop API Documentation

tree_parser.cpp

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 #include "tree_parser.h"
00021 #include <kdebug.h>
00022 
00023 TreeParser::TreeParser()
00024 {
00025 }
00026 
00027 TreeParser::~TreeParser()
00028 {
00029 }
00030 
00031 void TreeParser::parseTranslationUnit( TranslationUnitAST* translationUnit )
00032 {
00033     //kdDebug(9007) << "TreeParser::parseTranslationUnit()" << endl;
00034 
00035     QPtrList<DeclarationAST> declarations = translationUnit->declarationList();
00036     QPtrListIterator<DeclarationAST> it( declarations );
00037     while( it.current() ){
00038     parseDeclaration( it.current() );
00039     ++it;
00040     }
00041 }
00042 
00043 void TreeParser::parseDeclaration( DeclarationAST* declaration )
00044 {
00045     //kdDebug(9007) << "TreeParser::parseDeclaration()" << endl;
00046 
00047     if( !declaration )
00048         return;
00049 
00050     switch( declaration->nodeType() )
00051     {
00052     case NodeType_LinkageSpecification:
00053     parseLinkageSpecification( static_cast<LinkageSpecificationAST*>(declaration) );
00054     break;
00055 
00056     case NodeType_Namespace:
00057     parseNamespace( static_cast<NamespaceAST*>(declaration) );
00058     break;
00059 
00060     case NodeType_NamespaceAlias:
00061     parseNamespaceAlias( static_cast<NamespaceAliasAST*>(declaration) );
00062     break;
00063 
00064     case NodeType_Using:
00065     parseUsing( static_cast<UsingAST*>(declaration) );
00066     break;
00067 
00068     case NodeType_UsingDirective:
00069     parseUsingDirective( static_cast<UsingDirectiveAST*>(declaration) );
00070     break;
00071 
00072     case NodeType_Typedef:
00073     parseTypedef( static_cast<TypedefAST*>(declaration) );
00074     break;
00075 
00076     case NodeType_TemplateDeclaration:
00077     parseTemplateDeclaration( static_cast<TemplateDeclarationAST*>(declaration) );
00078     break;
00079 
00080     case NodeType_SimpleDeclaration:
00081     parseSimpleDeclaration( static_cast<SimpleDeclarationAST*>(declaration) );
00082     break;
00083 
00084     case NodeType_FunctionDefinition:
00085     parseFunctionDefinition( static_cast<FunctionDefinitionAST*>(declaration) );
00086     break;
00087 
00088     case NodeType_AccessDeclaration:
00089         parseAccessDeclaration( static_cast<AccessDeclarationAST*>(declaration) );
00090     break;
00091    }
00092 }
00093 
00094 void TreeParser::parseLinkageSpecification( LinkageSpecificationAST* ast )
00095 {
00096     //kdDebug(9007) << "TreeParser::parseLinkageSpecification()" << endl;
00097     if( ast->linkageBody() )
00098     parseLinkageBody( ast->linkageBody() );
00099     else if( ast->declaration() )
00100     parseDeclaration( ast->declaration() );
00101 }
00102 
00103 void TreeParser::parseNamespace( NamespaceAST* decl )
00104 {
00105     //kdDebug(9007) << "TreeParser::parseNamespace()" << endl;
00106     if( decl->linkageBody() )
00107     parseLinkageBody( decl->linkageBody() );
00108 }
00109 
00110 void TreeParser::parseNamespaceAlias( NamespaceAliasAST* decl )
00111 {
00112     //kdDebug(9007) << "TreeParser::parseNamespaceAlias()" << endl;
00113     Q_UNUSED( decl );
00114 }
00115 
00116 void TreeParser::parseUsing( UsingAST* decl )
00117 {
00118     //kdDebug(9007) << "TreeParser::parseUsing()" << endl;
00119     Q_UNUSED( decl );
00120 }
00121 
00122 void TreeParser::parseUsingDirective( UsingDirectiveAST* decl )
00123 {
00124     //kdDebug(9007) << "TreeParser::parseUsingDirective()" << endl;
00125     Q_UNUSED( decl );
00126 }
00127 
00128 void TreeParser::parseTypedef( TypedefAST* decl )
00129 {
00130     //kdDebug(9007) << "TreeParser::parseTypedef()" << endl;
00131     if( decl->typeSpec() )
00132     parseTypeSpecifier( decl->typeSpec() );
00133 }
00134 
00135 void TreeParser::parseTemplateDeclaration( TemplateDeclarationAST* decl )
00136 {
00137     //kdDebug(9007) << "TreeParser::parseTemplateDeclaration()" << endl;
00138     Q_UNUSED( decl );
00139 }
00140 
00141 void TreeParser::parseSimpleDeclaration( SimpleDeclarationAST* decl )
00142 {
00143     //kdDebug(9007) << "TreeParser::parseSimpleDeclaration()" << endl;
00144     Q_UNUSED( decl );
00145 }
00146 
00147 void TreeParser::parseFunctionDefinition( FunctionDefinitionAST* def )
00148 {
00149     //kdDebug(9007) << "TreeParser::parseFunctionDefinition()" << endl;
00150     Q_UNUSED( def );
00151 }
00152 
00153 void TreeParser::parseLinkageBody( LinkageBodyAST* linkageBody )
00154 {
00155     //kdDebug(9007) << "TreeParser::parseLinkageBody()" << endl;
00156     QPtrList<DeclarationAST> declarations = linkageBody->declarationList();
00157     for( QPtrListIterator<DeclarationAST> it(declarations); it.current(); ++it ){
00158     parseDeclaration( it.current() );
00159     }
00160 }
00161 
00162 void TreeParser::parseTypeSpecifier( TypeSpecifierAST* typeSpec )
00163 {
00164     //kdDebug(9007) << "TreeParser::parseTypeSpecifier()" << endl;
00165     switch( typeSpec->nodeType() )
00166     {
00167     case NodeType_ClassSpecifier:
00168     parseClassSpecifier( static_cast<ClassSpecifierAST*>(typeSpec) );
00169     break;
00170 
00171     case NodeType_EnumSpecifier:
00172     parseEnumSpecifier( static_cast<EnumSpecifierAST*>(typeSpec) );
00173     break;
00174 
00175     case NodeType_ElaboratedTypeSpecifier:
00176     parseElaboratedTypeSpecifier( static_cast<ElaboratedTypeSpecifierAST*>(typeSpec) );
00177     break;
00178     }
00179 }
00180 
00181 void TreeParser::parseClassSpecifier( ClassSpecifierAST* classSpec )
00182 {
00183     //kdDebug(9007) << "TreeParser::parseClassSpecifier()" << endl;
00184     QPtrList<DeclarationAST> declarations = classSpec->declarationList();
00185     for( QPtrListIterator<DeclarationAST> it(declarations); it.current(); ++it ){
00186     parseDeclaration( it.current() );
00187     }
00188 }
00189 
00190 void TreeParser::parseEnumSpecifier( EnumSpecifierAST* enumSpec )
00191 {
00192     //kdDebug(9007) << "TreeParser::parseEnumSpecifier()" << endl;
00193     Q_UNUSED( enumSpec );
00194 }
00195 
00196 void TreeParser::parseElaboratedTypeSpecifier( ElaboratedTypeSpecifierAST* typeSpec )
00197 {
00198     //kdDebug(9007) << "TreeParser::parseElaboratedTypeSpecifier()" << endl;
00199     Q_UNUSED( typeSpec );
00200 }
00201 
00202 void TreeParser::parseAccessDeclaration ( AccessDeclarationAST * access )
00203 {
00204     //kdDebug(9007) << "TreeParser::parseAccessDeclaration()" << endl;
00205     Q_UNUSED( access );
00206 }
00207 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:51 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003