KDevelop API Documentation

languages/cpp/store_walker.cpp

Go to the documentation of this file.
00001 /*************************************************************************** 00002 * Copyright (C) 2003 by Roberto Raggi * 00003 * roberto@kdevelop.org * 00004 * * 00005 * This program is free software; you can redistribute it and/or modify * 00006 * it under the terms of the GNU General Public License as published by * 00007 * the Free Software Foundation; either version 2 of the License, or * 00008 * (at your option) any later version. * 00009 * * 00010 ***************************************************************************/ 00011 00012 #include "store_walker.h" 00013 #include "ast_utils.h" 00014 #include "urlutil.h" 00015 00016 #include <kdebug.h> 00017 #include <qfileinfo.h> 00018 #include <qdir.h> 00019 00020 StoreWalker::StoreWalker( const QString& fileName, CodeModel* store ) 00021 : m_store( store ), m_anon( 0 ) 00022 { 00023 m_fileName = URLUtil::canonicalPath(fileName); 00024 00025 //kdDebug(9007) << "StoreWalker::StoreWalker(" << m_fileName << ")" << endl; 00026 } 00027 00028 StoreWalker::~StoreWalker() 00029 { 00030 } 00031 00032 void StoreWalker::parseTranslationUnit( TranslationUnitAST* ast ) 00033 { 00034 m_file = m_store->create<FileModel>(); 00035 m_file->setName( m_fileName ); 00036 00037 m_currentScope.clear(); 00038 m_currentNamespace.clear(); 00039 m_currentClass.clear(); 00040 00041 m_currentAccess = CodeModelItem::Public; 00042 m_inSlots = false; 00043 m_inSignals = false; 00044 m_inStorageSpec = false; 00045 m_inTypedef = false; 00046 m_currentDeclarator = 0; 00047 m_anon = 0; 00048 m_imports.clear(); 00049 00050 m_imports << QStringList(); 00051 TreeParser::parseTranslationUnit( ast ); 00052 m_imports.pop_back(); 00053 } 00054 00055 void StoreWalker::parseDeclaration( DeclarationAST* ast ) 00056 { 00057 TreeParser::parseDeclaration( ast ); 00058 } 00059 00060 void StoreWalker::parseLinkageSpecification( LinkageSpecificationAST* ast ) 00061 { 00062 int inStorageSpec = m_inStorageSpec; 00063 m_inStorageSpec = true; 00064 TreeParser::parseLinkageSpecification( ast ); 00065 m_inStorageSpec = inStorageSpec; 00066 } 00067 00068 void StoreWalker::parseNamespace( NamespaceAST* ast ) 00069 { 00070 if( !m_currentClass.isEmpty() ){ 00071 kdDebug(9007) << "!!!!!!!!!!!!!!!!!!!!!!!!!! **error** !!!!!!!!!!!!!!!!!!!!" << endl; 00072 return; 00073 } 00074 00075 QString nsName; 00076 if( !ast->namespaceName() || ast->namespaceName()->text().isEmpty() ){ 00077 QFileInfo fileInfo( m_fileName ); 00078 QString shortFileName = fileInfo.baseName(); 00079 00080 nsName.sprintf( "(%s_%d)", shortFileName.local8Bit().data(), m_anon++ ); 00081 } else { 00082 nsName = ast->namespaceName()->text(); 00083 } 00084 00085 NamespaceDom ns = findOrInsertNamespace( ast, nsName ); 00086 00087 m_currentScope.push_back( nsName ); 00088 m_currentNamespace.push( ns ); 00089 00090 TreeParser::parseNamespace( ast ); 00091 00092 m_currentNamespace.pop(); 00093 m_currentScope.pop_back(); 00094 } 00095 00096 void StoreWalker::parseNamespaceAlias( NamespaceAliasAST* ast ) 00097 { 00098 TreeParser::parseNamespaceAlias( ast ); 00099 } 00100 00101 void StoreWalker::parseUsing( UsingAST* ast ) 00102 { 00103 TreeParser::parseUsing( ast ); 00104 } 00105 00106 void StoreWalker::parseUsingDirective( UsingDirectiveAST* ast ) 00107 { 00108 QString name = ast->name()->unqualifiedName()->text(); 00109 m_imports.back().push_back( name ); 00110 } 00111 00112 void StoreWalker::parseTypedef( TypedefAST* ast ) 00113 { 00114 #if 0 00115 DeclaratorAST* oldDeclarator = m_currentDeclarator; 00116 00117 if( ast && ast->initDeclaratorList() && ast->initDeclaratorList()->initDeclaratorList().count() > 0 ) { 00118 QPtrList<InitDeclaratorAST> lst( ast->initDeclaratorList()->initDeclaratorList() ); 00119 m_currentDeclarator = lst.at( 0 )->declarator(); 00120 } 00121 00122 m_inTypedef = true; 00123 00124 TreeParser::parseTypedef( ast ); 00125 00126 m_inTypedef = false; 00127 m_currentDeclarator = oldDeclarator; 00128 #else 00129 TypeSpecifierAST* typeSpec = ast->typeSpec(); 00130 InitDeclaratorListAST* declarators = ast->initDeclaratorList(); 00131 00132 if( typeSpec && declarators ){ 00133 QString typeId; 00134 00135 if( typeSpec->name() ) 00136 typeId = typeSpec->name()->text(); 00137 00138 QPtrList<InitDeclaratorAST> l( declarators->initDeclaratorList() ); 00139 QPtrListIterator<InitDeclaratorAST> it( l ); 00140 00141 InitDeclaratorAST* initDecl = 0; 00142 while( 0 != (initDecl = it.current()) ){ 00143 00144 QString type, id; 00145 if( initDecl->declarator() ){ 00146 type = typeOfDeclaration( typeSpec, initDecl->declarator() ); 00147 00148 DeclaratorAST* d = initDecl->declarator(); 00149 while( d->subDeclarator() ){ 00150 d = d->subDeclarator(); 00151 } 00152 00153 if( d->declaratorId() ) 00154 id = d->declaratorId()->text(); 00155 } 00156 00157 TypeAliasDom typeAlias = m_store->create<TypeAliasModel>(); 00158 typeAlias->setFileName( m_fileName ); 00159 typeAlias->setName( id ); 00160 typeAlias->setType( type ); 00161 00162 int line, col; 00163 initDecl->getStartPosition( &line, &col ); 00164 typeAlias->setStartPosition( line, col ); 00165 00166 initDecl->getEndPosition( &line, &col ); 00167 typeAlias->setEndPosition( line, col ); 00168 00169 if( m_currentClass.top() ) 00170 m_currentClass.top()->addTypeAlias( typeAlias ); 00171 else if( m_currentNamespace.top() ) 00172 m_currentNamespace.top()->addTypeAlias( typeAlias ); 00173 else 00174 m_file->addTypeAlias( typeAlias ); 00175 00176 #if 0 00177 Tag tag; 00178 tag.setKind( Tag::Kind_Typedef ); 00179 tag.setFileName( m_fileName ); 00180 tag.setName( id ); 00181 tag.setScope( m_currentScope ); 00182 tag.setAttribute( "t", type ); 00183 int line, col; 00184 initDecl->getStartPosition( &line, &col ); 00185 00186 tag.setStartPosition( line, col ); 00187 00188 initDecl->getEndPosition( &line, &col ); 00189 tag.setEndPosition( line, col ); 00190 00191 m_catalog->addItem( tag ); 00192 #endif 00193 00194 ++it; 00195 } 00196 00197 } 00198 #endif 00199 } 00200 00201 void StoreWalker::parseTemplateDeclaration( TemplateDeclarationAST* ast ) 00202 { 00203 if( ast->declaration() ) 00204 parseDeclaration( ast->declaration() ); 00205 00206 TreeParser::parseTemplateDeclaration( ast ); 00207 } 00208 00209 void StoreWalker::parseSimpleDeclaration( SimpleDeclarationAST* ast ) 00210 { 00211 TypeSpecifierAST* typeSpec = ast->typeSpec(); 00212 InitDeclaratorListAST* declarators = ast->initDeclaratorList(); 00213 00214 if( typeSpec ) 00215 parseTypeSpecifier( typeSpec ); 00216 00217 if( declarators ){ 00218 QPtrList<InitDeclaratorAST> l = declarators->initDeclaratorList(); 00219 00220 QPtrListIterator<InitDeclaratorAST> it( l ); 00221 while( it.current() ){ 00222 parseDeclaration( ast->functionSpecifier(), ast->storageSpecifier(), typeSpec, it.current() ); 00223 ++it; 00224 } 00225 } 00226 } 00227 00228 void StoreWalker::parseFunctionDefinition( FunctionDefinitionAST* ast ) 00229 { 00230 TypeSpecifierAST* typeSpec = ast->typeSpec(); 00231 GroupAST* funSpec = ast->functionSpecifier(); 00232 GroupAST* storageSpec = ast->storageSpecifier(); 00233 00234 if( !ast->initDeclarator() ) 00235 return; 00236 00237 DeclaratorAST* d = ast->initDeclarator()->declarator(); 00238 00239 if( !d->declaratorId() ) 00240 return; 00241 00242 bool isFriend = false; 00243 bool isVirtual = false; 00244 bool isStatic = false; 00245 bool isInline = false; 00246 00247 if( funSpec ){ 00248 QPtrList<AST> l = funSpec->nodeList(); 00249 QPtrListIterator<AST> it( l ); 00250 while( it.current() ){ 00251 QString text = it.current()->text(); 00252 if( text == "virtual" ) isVirtual = true; 00253 else if( text == "inline" ) isInline = true; 00254 ++it; 00255 } 00256 } 00257 00258 if( storageSpec ){ 00259 QPtrList<AST> l = storageSpec->nodeList(); 00260 QPtrListIterator<AST> it( l ); 00261 while( it.current() ){ 00262 QString text = it.current()->text(); 00263 if( text == "friend" ) isFriend = true; 00264 else if( text == "static" ) isStatic = true; 00265 ++it; 00266 } 00267 } 00268 00269 int startLine, startColumn; 00270 int endLine, endColumn; 00271 ast->getStartPosition( &startLine, &startColumn ); 00272 ast->getEndPosition( &endLine, &endColumn ); 00273 00274 QString id = d->declaratorId()->unqualifiedName()->text().stripWhiteSpace(); 00275 00276 QStringList scope = scopeOfDeclarator( d, m_currentScope ); 00277 00278 FunctionDefinitionDom method = m_store->create<FunctionDefinitionModel>(); 00279 method->setScope( scope ); 00280 method->setName( id ); 00281 00282 parseFunctionArguments( d, model_cast<FunctionDom>(method) ); 00283 00284 QString text = typeOfDeclaration( typeSpec, d ); 00285 if( !text.isEmpty() ) 00286 method->setResultType( text ); 00287 00288 method->setFileName( m_fileName ); 00289 method->setStartPosition( startLine, startColumn ); 00290 method->setEndPosition( endLine, endColumn ); 00291 00292 if( m_inSignals ) 00293 method->setSignal( true ); 00294 00295 if( m_inSlots ) 00296 method->setSlot( true ); 00297 00298 if( m_currentClass.top() || (method->name() == "main" && scope.isEmpty()) ){ 00299 method->setConstant( d->constant() != 0 ); 00300 method->setAccess( m_currentAccess ); 00301 method->setStatic( isStatic ); 00302 method->setVirtual( isVirtual ); 00303 00304 if( m_currentClass.top() ) 00305 m_currentClass.top()->addFunction( model_cast<FunctionDom>(method) ); 00306 else 00307 m_file->addFunction( model_cast<FunctionDom>(method) ); 00308 } 00309 00310 if( m_currentClass.top() ) 00311 m_currentClass.top()->addFunctionDefinition( method ); 00312 else if( m_currentNamespace.top() ) 00313 m_currentNamespace.top()->addFunctionDefinition( method ); 00314 else 00315 m_file->addFunctionDefinition( method ); 00316 } 00317 00318 void StoreWalker::parseLinkageBody( LinkageBodyAST* ast ) 00319 { 00320 TreeParser::parseLinkageBody( ast ); 00321 } 00322 00323 void StoreWalker::parseTypeSpecifier( TypeSpecifierAST* ast ) 00324 { 00325 TreeParser::parseTypeSpecifier( ast ); 00326 } 00327 00328 void StoreWalker::parseClassSpecifier( ClassSpecifierAST* ast ) 00329 { 00330 int startLine, startColumn; 00331 int endLine, endColumn; 00332 ast->getStartPosition( &startLine, &startColumn ); 00333 ast->getEndPosition( &endLine, &endColumn ); 00334 00335 int oldAccess = m_currentAccess; 00336 bool oldInSlots = m_inSlots; 00337 bool oldInSignals = m_inSignals; 00338 00339 QString kind = ast->classKey()->text(); 00340 if( kind == "class" ) 00341 m_currentAccess = CodeModelItem::Private; 00342 else 00343 m_currentAccess = CodeModelItem::Public; 00344 m_inSlots = false; 00345 m_inSignals = false; 00346 00347 QString className; 00348 if( !ast->name() && m_currentDeclarator && m_currentDeclarator->declaratorId() ) { 00349 className = m_currentDeclarator->declaratorId()->text().stripWhiteSpace(); 00350 } else if( !ast->name() ){ 00351 QFileInfo fileInfo( m_fileName ); 00352 QString shortFileName = fileInfo.baseName(); 00353 className.sprintf( "(%s_%d)", shortFileName.local8Bit().data(), m_anon++ ); 00354 } else { 00355 className = ast->name()->unqualifiedName()->text().stripWhiteSpace(); 00356 } 00357 00358 if( !scopeOfName( ast->name(), QStringList() ).isEmpty() ){ 00359 kdDebug(9007) << "skip private class declarations" << endl; 00360 return; 00361 } 00362 00363 ClassDom klass = m_store->create<ClassModel>(); 00364 klass->setStartPosition( startLine, startColumn ); 00365 klass->setEndPosition( endLine, endColumn ); 00366 klass->setFileName( m_fileName ); 00367 00368 klass->setName( className ); 00369 00370 klass->setScope( m_currentScope ); 00371 00372 if( m_currentClass.top() ) 00373 m_currentClass.top()->addClass( klass ); 00374 else if( m_currentNamespace.top() ) 00375 m_currentNamespace.top()->addClass( klass ); 00376 else 00377 m_file->addClass( klass ); 00378 00379 if ( ast->baseClause() ) 00380 parseBaseClause( ast->baseClause(), klass ); 00381 00382 m_currentScope.push_back( className ); 00383 m_currentClass.push( klass ); 00384 00385 m_imports.push_back( QStringList() ); 00386 00387 TreeParser::parseClassSpecifier( ast ); 00388 00389 m_imports.pop_back(); 00390 m_currentClass.pop(); 00391 00392 m_currentScope.pop_back(); 00393 00394 m_currentAccess = oldAccess; 00395 m_inSlots = oldInSlots; 00396 m_inSignals = oldInSignals; 00397 } 00398 00399 void StoreWalker::parseEnumSpecifier( EnumSpecifierAST* ast ) 00400 { 00401 QPtrList<EnumeratorAST> l = ast->enumeratorList(); 00402 QPtrListIterator<EnumeratorAST> it( l ); 00403 while( it.current() ){ 00404 VariableDom attr = m_store->create<VariableModel>(); 00405 attr->setName( it.current()->id()->text() ); 00406 attr->setFileName( m_fileName ); 00407 attr->setAccess( m_currentAccess ); 00408 attr->setType( "int" ); 00409 attr->setStatic( true ); 00410 00411 int startLine, startColumn; 00412 int endLine, endColumn; 00413 it.current()->getStartPosition( &startLine, &startColumn ); 00414 attr->setStartPosition( startLine, startColumn ); 00415 00416 it.current()->getEndPosition( &endLine, &endColumn ); 00417 attr->setEndPosition( endLine, endColumn ); 00418 00419 if( m_currentClass.top() ) 00420 m_currentClass.top()->addVariable( attr ); 00421 else if( m_currentNamespace.top() ) 00422 m_currentNamespace.top()->addVariable( attr ); 00423 else 00424 m_file->addVariable( attr ); 00425 00426 ++it; 00427 } 00428 } 00429 00430 void StoreWalker::parseElaboratedTypeSpecifier( ElaboratedTypeSpecifierAST* ast ) 00431 { 00432 TreeParser::parseElaboratedTypeSpecifier( ast ); 00433 } 00434 00435 void StoreWalker::parseTypeDeclaratation( TypeSpecifierAST* typeSpec ) 00436 { 00437 parseTypeSpecifier( typeSpec ); 00438 } 00439 00440 void StoreWalker::parseDeclaration( GroupAST* funSpec, GroupAST* storageSpec, TypeSpecifierAST* typeSpec, InitDeclaratorAST* decl ) 00441 { 00442 if( m_inStorageSpec ) 00443 return; 00444 00445 DeclaratorAST* d = decl->declarator(); 00446 00447 if( !d ) 00448 return; 00449 00450 if( !d->subDeclarator() && d->parameterDeclarationClause() ) 00451 return parseFunctionDeclaration( funSpec, storageSpec, typeSpec, decl ); 00452 00453 DeclaratorAST* t = d; 00454 while( t && t->subDeclarator() ) 00455 t = t->subDeclarator(); 00456 00457 QString id; 00458 if( t && t->declaratorId() && t->declaratorId()->unqualifiedName() ) 00459 id = t->declaratorId()->unqualifiedName()->text(); 00460 00461 if( !scopeOfDeclarator(d, QStringList()).isEmpty() ){ 00462 kdDebug(9007) << "skip declaration" << endl; 00463 return; 00464 } 00465 00466 VariableDom attr = m_store->create<VariableModel>(); 00467 attr->setName( id ); 00468 attr->setFileName( m_fileName ); 00469 00470 if( m_currentClass.top() ) 00471 m_currentClass.top()->addVariable( attr ); 00472 else if( m_currentNamespace.top() ) 00473 m_currentNamespace.top()->addVariable( attr ); 00474 else 00475 m_file->addVariable( attr ); 00476 00477 attr->setAccess( m_currentAccess ); 00478 00479 QString text = typeOfDeclaration( typeSpec, d ); 00480 if( !text.isEmpty() ) 00481 attr->setType( text ); 00482 00483 bool isFriend = false; 00484 //bool isVirtual = false; 00485 bool isStatic = false; 00486 //bool isInline = false; 00487 //bool isInitialized = decl->initializer() != 0; 00488 00489 if( storageSpec ){ 00490 QPtrList<AST> l = storageSpec->nodeList(); 00491 QPtrListIterator<AST> it( l ); 00492 while( it.current() ){ 00493 QString text = it.current()->text(); 00494 if( text == "friend" ) isFriend = true; 00495 else if( text == "static" ) isStatic = true; 00496 ++it; 00497 } 00498 } 00499 00500 int startLine, startColumn; 00501 int endLine, endColumn; 00502 decl->getStartPosition( &startLine, &startColumn ); 00503 decl->getEndPosition( &endLine, &endColumn ); 00504 00505 attr->setStartPosition( startLine, startColumn ); 00506 attr->setEndPosition( endLine, endColumn ); 00507 attr->setStatic( isStatic ); 00508 } 00509 00510 void StoreWalker::parseAccessDeclaration( AccessDeclarationAST * access ) 00511 { 00512 QPtrList<AST> l = access->accessList(); 00513 00514 QString accessStr = l.at( 0 )->text(); 00515 if( accessStr == "public" ) 00516 m_currentAccess = CodeModelItem::Public; 00517 else if( accessStr == "protected" ) 00518 m_currentAccess = CodeModelItem::Protected; 00519 else if( accessStr == "private" ) 00520 m_currentAccess = CodeModelItem::Private; 00521 else if( accessStr == "signals" ) 00522 m_currentAccess = CodeModelItem::Protected; 00523 else 00524 m_currentAccess = CodeModelItem::Public; 00525 00526 m_inSlots = l.count() > 1 ? l.at( 1 )->text() == "slots" : false; 00527 m_inSignals = l.count() >= 1 ? l.at( 0 )->text() == "signals" : false; 00528 } 00529 00530 NamespaceDom StoreWalker::findOrInsertNamespace( NamespaceAST* ast, const QString & name ) 00531 { 00532 if( m_currentNamespace.top() && m_currentNamespace.top()->hasNamespace(name) ) 00533 return m_currentNamespace.top()->namespaceByName( name ); 00534 00535 if( m_file->hasNamespace(name) ) 00536 return m_file->namespaceByName( name ); 00537 00538 int startLine, startColumn; 00539 int endLine, endColumn; 00540 ast->getStartPosition( &startLine, &startColumn ); 00541 ast->getEndPosition( &endLine, &endColumn ); 00542 00543 NamespaceDom ns = m_store->create<NamespaceModel>(); 00544 ns->setFileName( m_fileName ); 00545 ns->setName( name ); 00546 ns->setStartPosition( startLine, startColumn ); 00547 ns->setEndPosition( endLine, endColumn ); 00548 00549 ns->setScope( m_currentScope ); 00550 00551 if( m_currentNamespace.top() ) 00552 m_currentNamespace.top()->addNamespace( ns ); 00553 else 00554 m_file->addNamespace( ns ); 00555 00556 return ns; 00557 } 00558 00559 void StoreWalker::parseFunctionDeclaration( GroupAST* funSpec, GroupAST* storageSpec, 00560 TypeSpecifierAST * typeSpec, InitDeclaratorAST * decl ) 00561 { 00562 bool isFriend = false; 00563 bool isVirtual = false; 00564 bool isStatic = false; 00565 bool isInline = false; 00566 bool isPure = decl->initializer() != 0; 00567 00568 if( funSpec ){ 00569 QPtrList<AST> l = funSpec->nodeList(); 00570 QPtrListIterator<AST> it( l ); 00571 while( it.current() ){ 00572 QString text = it.current()->text(); 00573 if( text == "virtual" ) isVirtual = true; 00574 else if( text == "inline" ) isInline = true; 00575 ++it; 00576 } 00577 } 00578 00579 if( storageSpec ){ 00580 QPtrList<AST> l = storageSpec->nodeList(); 00581 QPtrListIterator<AST> it( l ); 00582 while( it.current() ){ 00583 QString text = it.current()->text(); 00584 if( text == "friend" ) isFriend = true; 00585 else if( text == "static" ) isStatic = true; 00586 ++it; 00587 } 00588 } 00589 00590 int startLine, startColumn; 00591 int endLine, endColumn; 00592 decl->getStartPosition( &startLine, &startColumn ); 00593 decl->getEndPosition( &endLine, &endColumn ); 00594 00595 DeclaratorAST* d = decl->declarator(); 00596 QString id = d->declaratorId()->unqualifiedName()->text(); 00597 00598 FunctionDom method = m_store->create<FunctionModel>(); 00599 method->setName( id ); 00600 00601 method->setFileName( m_fileName ); 00602 method->setStartPosition( startLine, startColumn ); 00603 method->setEndPosition( endLine, endColumn ); 00604 method->setAccess( m_currentAccess ); 00605 method->setStatic( isStatic ); 00606 method->setVirtual( isVirtual ); 00607 method->setAbstract( isPure ); 00608 parseFunctionArguments( d, method ); 00609 00610 if( m_inSignals ) 00611 method->setSignal( true ); 00612 00613 if( m_inSlots ) 00614 method->setSlot( true ); 00615 00616 QString text = typeOfDeclaration( typeSpec, d ); 00617 if( !text.isEmpty() ) 00618 method->setResultType( text ); 00619 00620 method->setConstant( d->constant() != 0 ); 00621 method->setScope( scopeOfDeclarator(d, m_currentScope) ); 00622 00623 if( m_currentClass.top() ) 00624 m_currentClass.top()->addFunction( method ); 00625 else if( m_currentNamespace.top() ) 00626 m_currentNamespace.top()->addFunction( method ); 00627 else 00628 m_file->addFunction( method ); 00629 } 00630 00631 void StoreWalker::parseFunctionArguments( DeclaratorAST* declarator, FunctionDom method ) 00632 { 00633 ParameterDeclarationClauseAST* clause = declarator->parameterDeclarationClause(); 00634 00635 if( clause && clause->parameterDeclarationList() ){ 00636 ParameterDeclarationListAST* params = clause->parameterDeclarationList(); 00637 QPtrList<ParameterDeclarationAST> l( params->parameterList() ); 00638 QPtrListIterator<ParameterDeclarationAST> it( l ); 00639 while( it.current() ){ 00640 ParameterDeclarationAST* param = it.current(); 00641 ++it; 00642 00643 ArgumentDom arg = m_store->create<ArgumentModel>(); 00644 00645 if( param->declarator() ){ 00646 QString text = declaratorToString(param->declarator(), QString::null, true ); 00647 if( !text.isEmpty() ) 00648 arg->setName( text ); 00649 } 00650 00651 QString tp = typeOfDeclaration( param->typeSpec(), param->declarator() ); 00652 if( !tp.isEmpty() ) 00653 arg->setType( tp ); 00654 00655 method->addArgument( arg ); 00656 } 00657 } 00658 } 00659 00660 QString StoreWalker::typeOfDeclaration( TypeSpecifierAST* typeSpec, DeclaratorAST* declarator ) 00661 { 00662 if( !typeSpec || !declarator ) 00663 return QString::null; 00664 00665 QString text; 00666 00667 text += typeSpec->text(); 00668 00669 QPtrList<AST> ptrOpList = declarator->ptrOpList(); 00670 for( QPtrListIterator<AST> it(ptrOpList); it.current(); ++it ){ 00671 text += it.current()->text(); 00672 } 00673 00674 return text; 00675 } 00676 00677 void StoreWalker::parseBaseClause( BaseClauseAST * baseClause, ClassDom klass ) 00678 { 00679 QPtrList<BaseSpecifierAST> l = baseClause->baseSpecifierList(); 00680 QPtrListIterator<BaseSpecifierAST> it( l ); 00681 while( it.current() ){ 00682 BaseSpecifierAST* baseSpecifier = it.current(); 00683 00684 QString baseName; 00685 if( baseSpecifier->name() ) 00686 baseName = baseSpecifier->name()->text(); 00687 00688 klass->addBaseClass( baseName ); 00689 00690 ++it; 00691 } 00692 } 00693 00694 QStringList StoreWalker::scopeOfName( NameAST* id, const QStringList& startScope ) 00695 { 00696 QStringList scope = startScope; 00697 if( id && id->classOrNamespaceNameList().count() ){ 00698 if( id->isGlobal() ) 00699 scope.clear(); 00700 QPtrList<ClassOrNamespaceNameAST> l = id->classOrNamespaceNameList(); 00701 QPtrListIterator<ClassOrNamespaceNameAST> it( l ); 00702 while( it.current() ){ 00703 if( it.current()->name() ){ 00704 scope << it.current()->name()->text(); 00705 } 00706 ++it; 00707 } 00708 } 00709 00710 return scope; 00711 } 00712 00713 QStringList StoreWalker::scopeOfDeclarator( DeclaratorAST* d, const QStringList& startScope ) 00714 { 00715 return scopeOfName( d->declaratorId(), startScope ); 00716 }
KDE Logo
This file is part of the documentation for KDevelop Version 3.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Oct 6 17:39:02 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003