KDevelop API Documentation

languages/cpp/tag_creator.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 "tag_creator.h" 00013 #include "catalog.h" 00014 #include "ast_utils.h" 00015 #include "cpp_tags.h" 00016 #include "doxydoc.h" 00017 00018 #include <kdebug.h> 00019 #include <qfileinfo.h> 00020 #include <qregexp.h> 00021 00022 DoxyDoc* TagCreator::m_documentation = new DoxyDoc( QStringList() ); 00023 00024 TagCreator::TagCreator( const QString& fileName, Catalog* c ) 00025 : m_catalog( c ), m_fileName( fileName ), m_anon( 0 ) 00026 { 00027 } 00028 00029 TagCreator::~TagCreator() 00030 { 00031 } 00032 00033 void TagCreator::destroyDocumentation(){ 00034 delete m_documentation; 00035 } 00036 00037 void TagCreator::setDocumentationDirectories(const QStringList& str){ 00038 if (m_documentation) 00039 delete m_documentation; 00040 m_documentation = new DoxyDoc(str); 00041 } 00042 00043 void TagCreator::parseDeclaration( DeclarationAST* ast ) 00044 { 00045 if( ast->nodeType() == NodeType_AccessDeclaration || 00046 m_currentAccess.isEmpty() || 00047 m_currentAccess.contains("public") || 00048 m_currentAccess.contains("protected") || 00049 m_currentAccess.contains("signals") ) 00050 00051 TreeParser::parseDeclaration( ast ); 00052 } 00053 00054 void TagCreator::parseTranslationUnit( TranslationUnitAST* ast ) 00055 { 00056 m_currentScope.clear(); 00057 m_currentAccess = QString::null; 00058 m_inSlots = false; 00059 m_inSignals = false; 00060 m_anon = 0; 00061 m_imports.clear(); 00062 m_inClass = false; 00063 00064 m_imports << QStringList(); 00065 TreeParser::parseTranslationUnit( ast ); 00066 m_imports.pop_back(); 00067 } 00068 00069 void TagCreator::parseNamespace( NamespaceAST* ast ) 00070 { 00071 QString nsName; 00072 if( !ast->namespaceName() || ast->namespaceName()->text().isEmpty() ){ 00073 // anonymous namespace 00074 } else { 00075 nsName = ast->namespaceName()->text(); 00076 } 00077 00078 Tag tag; 00079 tag.setKind( Tag::Kind_Namespace ); 00080 tag.setFileName( m_fileName ); 00081 tag.setName( nsName ); 00082 tag.setScope( m_currentScope ); 00083 00084 int line, col; 00085 ast->getStartPosition( &line, &col ); 00086 tag.setStartPosition( line, col ); 00087 00088 ast->getEndPosition( &line, &col ); 00089 tag.setEndPosition( line, col ); 00090 00091 m_catalog->addItem( tag ); 00092 00093 m_currentScope.push_back( nsName ); 00094 TreeParser::parseNamespace( ast ); 00095 m_currentScope.pop_back(); 00096 } 00097 00098 void TagCreator::parseElaboratedTypeSpecifier( ElaboratedTypeSpecifierAST* ast ) 00099 { 00100 TreeParser::parseElaboratedTypeSpecifier( ast ); 00101 } 00102 00103 void TagCreator::parseUsingDirective( UsingDirectiveAST* ast ) 00104 { 00105 QString name; 00106 if( ast->name() ) 00107 name = ast->name()->text(); 00108 00109 if( !name.isNull() ){ 00110 Tag tag; 00111 tag.setKind( Tag::Kind_UsingDirective ); 00112 tag.setFileName( m_fileName ); 00113 tag.setName( name ); 00114 tag.setScope( m_currentScope ); 00115 00116 int line, col; 00117 ast->getStartPosition( &line, &col ); 00118 tag.setStartPosition( line, col ); 00119 00120 ast->getEndPosition( &line, &col ); 00121 tag.setEndPosition( line, col ); 00122 00123 m_catalog->addItem( tag ); 00124 } 00125 00126 m_imports.back().push_back( name ); 00127 } 00128 00129 void TagCreator::parseTypedef( TypedefAST* ast ) 00130 { 00131 TypeSpecifierAST* typeSpec = ast->typeSpec(); 00132 InitDeclaratorListAST* declarators = ast->initDeclaratorList(); 00133 00134 if( typeSpec && declarators ){ 00135 QString typeId; 00136 00137 if( typeSpec->name() ) 00138 typeId = typeSpec->name()->text(); 00139 00140 QPtrList<InitDeclaratorAST> l( declarators->initDeclaratorList() ); 00141 QPtrListIterator<InitDeclaratorAST> it( l ); 00142 00143 InitDeclaratorAST* initDecl = 0; 00144 while( 0 != (initDecl = it.current()) ){ 00145 00146 QString type, id; 00147 if( initDecl->declarator() ){ 00148 type = typeOfDeclaration( typeSpec, initDecl->declarator() ); 00149 00150 DeclaratorAST* d = initDecl->declarator(); 00151 while( d->subDeclarator() ){ 00152 d = d->subDeclarator(); 00153 } 00154 00155 if( d->declaratorId() ) 00156 id = d->declaratorId()->text(); 00157 } 00158 00159 Tag tag; 00160 tag.setKind( Tag::Kind_Typedef ); 00161 tag.setFileName( m_fileName ); 00162 tag.setName( id ); 00163 tag.setScope( m_currentScope ); 00164 tag.setAttribute( "t", type ); 00165 00166 int line, col; 00167 initDecl->getStartPosition( &line, &col ); 00168 tag.setStartPosition( line, col ); 00169 00170 initDecl->getEndPosition( &line, &col ); 00171 tag.setEndPosition( line, col ); 00172 00173 m_catalog->addItem( tag ); 00174 00175 ++it; 00176 } 00177 00178 } 00179 } 00180 00181 void TagCreator::parseTemplateDeclaration( TemplateDeclarationAST* ast ) 00182 { 00183 if( ast->declaration() ) 00184 parseDeclaration( ast->declaration() ); 00185 00186 TreeParser::parseTemplateDeclaration( ast ); 00187 } 00188 00189 void TagCreator::parseSimpleDeclaration( SimpleDeclarationAST* ast ) 00190 { 00191 TypeSpecifierAST* typeSpec = ast->typeSpec(); 00192 InitDeclaratorListAST* declarators = ast->initDeclaratorList(); 00193 00194 if( typeSpec ) 00195 parseTypeSpecifier( typeSpec ); 00196 00197 if( declarators ){ 00198 QPtrList<InitDeclaratorAST> l = declarators->initDeclaratorList(); 00199 00200 QPtrListIterator<InitDeclaratorAST> it( l ); 00201 while( it.current() ){ 00202 parseMyDeclaration( ast->functionSpecifier(), ast->storageSpecifier(), typeSpec, it.current() ); 00203 ++it; 00204 } 00205 } 00206 } 00207 00208 void TagCreator::parseFunctionDefinition( FunctionDefinitionAST* ast ) 00209 { 00210 TypeSpecifierAST* typeSpec = ast->typeSpec(); 00211 GroupAST* funSpec = ast->functionSpecifier(); 00212 GroupAST* storageSpec = ast->storageSpecifier(); 00213 00214 if( !ast->initDeclarator() ) 00215 return; 00216 00217 DeclaratorAST* d = ast->initDeclarator()->declarator(); 00218 00219 if( !d->declaratorId() ) 00220 return; 00221 00222 bool isFriend = false; 00223 bool isVirtual = false; 00224 bool isStatic = false; 00225 bool isInline = false; 00226 00227 if( funSpec ){ 00228 QPtrList<AST> l = funSpec->nodeList(); 00229 QPtrListIterator<AST> it( l ); 00230 while( it.current() ){ 00231 QString text = it.current()->text(); 00232 if( text == "virtual" ) isVirtual = true; 00233 else if( text == "inline" ) isInline = true; 00234 ++it; 00235 } 00236 } 00237 00238 if( storageSpec ){ 00239 QPtrList<AST> l = storageSpec->nodeList(); 00240 QPtrListIterator<AST> it( l ); 00241 while( it.current() ){ 00242 QString text = it.current()->text(); 00243 if( text == "friend" ) isFriend = true; 00244 else if( text == "static" ) isStatic = true; 00245 ++it; 00246 } 00247 } 00248 00249 00250 QString id = d->declaratorId()->unqualifiedName()->text().stripWhiteSpace(); 00251 QString scopeStr = scopeOfDeclarator( d ); 00252 00253 Tag tag; 00254 CppFunction<Tag> tagBuilder( tag ); 00255 tag.setKind( Tag::Kind_Function ); 00256 00257 tag.setFileName( m_fileName ); 00258 tag.setName( id ); 00259 tag.setScope( QStringList::split(".", scopeStr) ); 00260 00261 int line, col; 00262 ast->getStartPosition( &line, &col ); 00263 tag.setStartPosition( line, col ); 00264 00265 ast->getEndPosition( &line, &col ); 00266 tag.setEndPosition( line, col ); 00267 00268 tagBuilder.setType( typeOfDeclaration(typeSpec, d) ); 00269 00270 parseFunctionArguments( tag, d ); 00271 00272 QString arguments = tag.attribute("a").toStringList().join(","); 00273 tag.setAttribute("description", m_documentation->functionDescription(scopeStr.replace(QRegExp("."),":"), id, typeOfDeclaration(typeSpec, d), arguments)); 00274 00275 tagBuilder.setAccess( TagUtils::stringToAccess(m_currentAccess) ); 00276 00277 tagBuilder.setFriend( isFriend ); 00278 tagBuilder.setVirtual( isVirtual ); 00279 tagBuilder.setStatic( isStatic ); 00280 tagBuilder.setInline( isInline ); 00281 tagBuilder.setPure( false ); 00282 tagBuilder.setConst( d->constant() != 0 ); 00283 tagBuilder.setSignal( m_inSignals ); 00284 tagBuilder.setSlot( m_inSlots ); 00285 00286 m_catalog->addItem( tag ); 00287 00288 if( !m_currentAccess.isEmpty() ){ 00289 tag.setKind( Tag::Kind_FunctionDeclaration ); 00290 m_catalog->addItem( tag ); 00291 } 00292 } 00293 00294 void TagCreator::parseLinkageBody( LinkageBodyAST* ast ) 00295 { 00296 QPtrList<DeclarationAST> l = ast->declarationList(); 00297 QPtrListIterator<DeclarationAST> it( l ); 00298 while( it.current() ){ 00299 parseDeclaration( it.current() ); 00300 ++it; 00301 } 00302 } 00303 00304 void TagCreator::parseClassSpecifier( ClassSpecifierAST* ast ) 00305 { 00306 int startLine, startColumn; 00307 int endLine, endColumn; 00308 ast->getStartPosition( &startLine, &startColumn ); 00309 ast->getEndPosition( &endLine, &endColumn ); 00310 00311 QString oldAccess = m_currentAccess; 00312 bool oldInSlots = m_inSlots; 00313 bool oldInSignals = m_inSignals; 00314 00315 QString kind = ast->classKey()->text(); 00316 if( kind == "class" ) 00317 m_currentAccess = "private"; 00318 else 00319 m_currentAccess = "public"; 00320 m_inSlots = false; 00321 m_inSignals = false; 00322 00323 QString className; 00324 if( !ast->name() ){ 00325 //QFileInfo fileInfo( m_fileName ); 00326 //QString shortFileName = fileInfo.baseName(); 00327 //className.sprintf( "(%s_%d)", shortFileName.local8Bit(), m_anon++ ); 00328 } else { 00329 className = ast->name()->text(); 00330 } 00331 00332 Tag tag; 00333 tag.setKind( Tag::Kind_Class ); 00334 00335 tag.setFileName( m_fileName ); 00336 tag.setName( className ); 00337 tag.setScope( m_currentScope ); 00338 00339 int line, col; 00340 ast->getStartPosition( &line, &col ); 00341 tag.setStartPosition( line, col ); 00342 00343 ast->getEndPosition( &line, &col ); 00344 tag.setEndPosition( line, col ); 00345 00346 m_catalog->addItem( tag ); 00347 00348 if ( ast->baseClause() ) 00349 parseBaseClause( tag.path(), ast->baseClause() ); 00350 00351 m_currentScope.push_back( className ); 00352 int oldInClass = m_inClass; 00353 m_inClass = true; 00354 TreeParser::parseClassSpecifier( ast ); 00355 m_currentScope.pop_back(); 00356 m_inClass = oldInClass; 00357 00358 m_currentAccess = oldAccess; 00359 m_inSlots = oldInSlots; 00360 m_inSignals = oldInSignals; 00361 } 00362 00363 void TagCreator::parseEnumSpecifier( EnumSpecifierAST* ast ) 00364 { 00365 Tag tag; 00366 tag.setKind( Tag::Kind_Enum ); 00367 00368 tag.setFileName( m_fileName ); 00369 if( ast->name() ) 00370 tag.setName( ast->name()->text() ); 00371 tag.setScope( m_currentScope ); 00372 00373 int line, col; 00374 ast->getStartPosition( &line, &col ); 00375 tag.setStartPosition( line, col ); 00376 00377 ast->getEndPosition( &line, &col ); 00378 tag.setEndPosition( line, col ); 00379 00380 m_catalog->addItem( tag ); 00381 00382 QPtrList<EnumeratorAST> l = ast->enumeratorList(); 00383 QPtrListIterator<EnumeratorAST> it( l ); 00384 while( it.current() ){ 00385 QString name = it.current()->id()->text(); 00386 00387 Tag tag; 00388 tag.setKind( Tag::Kind_Enumerator ); 00389 00390 tag.setFileName( m_fileName ); 00391 tag.setName( name ); 00392 tag.setScope( m_currentScope ); 00393 00394 int line, col; 00395 it.current()->getStartPosition( &line, &col ); 00396 tag.setStartPosition( line, col ); 00397 00398 it.current()->getEndPosition( &line, &col ); 00399 tag.setEndPosition( line, col ); 00400 00401 m_catalog->addItem( tag ); 00402 00403 ++it; 00404 } 00405 00406 TreeParser::parseEnumSpecifier( ast ); 00407 } 00408 00409 void TagCreator::parseMyDeclaration( GroupAST* funSpec, GroupAST* storageSpec, TypeSpecifierAST* typeSpec, InitDeclaratorAST* decl ) 00410 { 00411 DeclaratorAST* d = decl->declarator(); 00412 00413 if( !d ) 00414 return; 00415 00416 if( !d->subDeclarator() && d->parameterDeclarationClause() ) 00417 return parseFunctionDeclaration( funSpec, storageSpec, typeSpec, decl ); 00418 00419 DeclaratorAST* t = d; 00420 while( t && t->subDeclarator() ) 00421 t = t->subDeclarator(); 00422 00423 QString id; 00424 if( t && t->declaratorId() && t->declaratorId()->unqualifiedName() ) 00425 id = t->declaratorId()->unqualifiedName()->text(); 00426 00427 QString scopeStr = scopeOfDeclarator( d ); 00428 00429 QString type = typeOfDeclaration( typeSpec, d ); 00430 00431 00432 bool isFriend = false; 00433 //bool isVirtual = false; 00434 bool isStatic = false; 00435 //bool isInline = false; 00436 //bool isInitialized = decl->initializer() != 0; 00437 00438 if( storageSpec ){ 00439 QPtrList<AST> l = storageSpec->nodeList(); 00440 QPtrListIterator<AST> it( l ); 00441 while( it.current() ){ 00442 QString text = it.current()->text(); 00443 if( text == "friend" ) isFriend = true; 00444 else if( text == "static" ) isStatic = true; 00445 ++it; 00446 } 00447 } 00448 00449 Tag tag; 00450 CppVariable<Tag> tagBuilder( tag ); 00451 00452 tag.setKind( Tag::Kind_Variable ); 00453 tag.setFileName( m_fileName ); 00454 tag.setName( id ); 00455 tag.setScope( QStringList::split(".",scopeStr) ); 00456 00457 int line, col; 00458 decl->getStartPosition( &line, &col ); 00459 tag.setStartPosition( line, col ); 00460 00461 decl->getEndPosition( &line, &col ); 00462 tag.setEndPosition( line, col ); 00463 00464 tagBuilder.setType( type ); 00465 tagBuilder.setFriend( isFriend ); 00466 tagBuilder.setStatic( isStatic ); 00467 tagBuilder.setAccess( TagUtils::stringToAccess(m_currentAccess) ); 00468 00469 m_catalog->addItem( tag ); 00470 } 00471 00472 void TagCreator::parseAccessDeclaration( AccessDeclarationAST * access ) 00473 { 00474 QPtrList<AST> l = access->accessList(); 00475 00476 m_currentAccess = l.at( 0 )->text(); 00477 if( m_currentAccess == "signals" ) 00478 m_currentAccess = "public"; 00479 00480 m_inSlots = l.count() > 1 ? l.at( 1 )->text() == "slots" : false; 00481 m_inSignals = l.count() >= 1 ? l.at( 0 )->text() == "signals" : false; 00482 } 00483 00484 void TagCreator::parseFunctionDeclaration( GroupAST* funSpec, GroupAST* storageSpec, 00485 TypeSpecifierAST * typeSpec, InitDeclaratorAST * decl ) 00486 { 00487 bool isFriend = false; 00488 bool isVirtual = false; 00489 bool isStatic = false; 00490 bool isInline = false; 00491 bool isPure = decl->initializer() != 0; 00492 00493 if( funSpec ){ 00494 QPtrList<AST> l = funSpec->nodeList(); 00495 QPtrListIterator<AST> it( l ); 00496 while( it.current() ){ 00497 QString text = it.current()->text(); 00498 if( text == "virtual" ) isVirtual = true; 00499 else if( text == "inline" ) isInline = true; 00500 ++it; 00501 } 00502 } 00503 00504 if( storageSpec ){ 00505 QPtrList<AST> l = storageSpec->nodeList(); 00506 QPtrListIterator<AST> it( l ); 00507 while( it.current() ){ 00508 QString text = it.current()->text(); 00509 if( text == "friend" ) isFriend = true; 00510 else if( text == "static" ) isStatic = true; 00511 ++it; 00512 } 00513 } 00514 00515 int startLine, startColumn; 00516 int endLine, endColumn; 00517 decl->getStartPosition( &startLine, &startColumn ); 00518 decl->getEndPosition( &endLine, &endColumn ); 00519 00520 DeclaratorAST* d = decl->declarator(); 00521 QString id = d->declaratorId()->unqualifiedName()->text(); 00522 00523 QString type = typeOfDeclaration( typeSpec, d ); 00524 00525 Tag tag; 00526 CppFunction<Tag> tagBuilder( tag ); 00527 00528 tag.setKind( Tag::Kind_FunctionDeclaration ); 00529 tag.setFileName( m_fileName ); 00530 tag.setName( id ); 00531 tag.setScope( m_currentScope ); 00532 00533 int line, col; 00534 decl->getStartPosition( &line, &col ); 00535 tag.setStartPosition( line, col ); 00536 00537 decl->getEndPosition( &line, &col ); 00538 tag.setEndPosition( line, col ); 00539 00540 tagBuilder.setType( type ); 00541 tagBuilder.setFriend( isFriend ); 00542 tagBuilder.setVirtual( isVirtual ); 00543 tagBuilder.setStatic( isStatic ); 00544 tagBuilder.setInline( isInline ); 00545 tagBuilder.setPure( isPure ); 00546 tagBuilder.setConst( d->constant() != 0 ); 00547 tagBuilder.setSignal( m_inSignals ); 00548 tagBuilder.setSlot( m_inSlots ); 00549 00550 parseFunctionArguments( tag, d ); 00551 00552 QString arguments = tag.attribute("a").toStringList().join(","); 00553 QString scopeStr = m_currentScope.join("::"); 00554 tag.setAttribute("description", m_documentation->functionDescription(scopeStr, id, type, arguments)); 00555 00556 m_catalog->addItem( tag ); 00557 } 00558 00559 void TagCreator::parseFunctionArguments( Tag& tag, DeclaratorAST* declarator ) 00560 { 00561 ParameterDeclarationClauseAST* clause = declarator->parameterDeclarationClause(); 00562 00563 QStringList types; 00564 QStringList args; 00565 if( clause && clause->parameterDeclarationList() ){ 00566 ParameterDeclarationListAST* params = clause->parameterDeclarationList(); 00567 QPtrList<ParameterDeclarationAST> l( params->parameterList() ); 00568 QPtrListIterator<ParameterDeclarationAST> it( l ); 00569 00570 while( it.current() ){ 00571 ParameterDeclarationAST* param = it.current(); 00572 ++it; 00573 00574 QString name; 00575 if( param->declarator() ){ 00576 name = declaratorToString(param->declarator(), QString::null, true ); 00577 } 00578 00579 QString type = typeOfDeclaration( param->typeSpec(), param->declarator() ); 00580 00581 types << type; 00582 args << name; 00583 } 00584 00585 if( clause->ellipsis() ){ 00586 types << "..."; 00587 args << ""; 00588 } 00589 00590 } 00591 00592 CppFunction<Tag> tagBuilder( tag ); 00593 00594 tagBuilder.setArguments( types ); 00595 tagBuilder.setArgumentNames( args ); 00596 } 00597 00598 QString TagCreator::typeOfDeclaration( TypeSpecifierAST* typeSpec, DeclaratorAST* declarator ) 00599 { 00600 if( !typeSpec || !declarator ) 00601 return QString::null; 00602 00603 QString text; 00604 00605 text += typeSpec->text(); 00606 text = text.simplifyWhiteSpace(); 00607 00608 QPtrList<AST> ptrOpList = declarator->ptrOpList(); 00609 for( QPtrListIterator<AST> it(ptrOpList); it.current(); ++it ){ 00610 text += it.current()->text(); 00611 } 00612 00613 return text; 00614 } 00615 00616 void TagCreator::parseBaseClause( const QString& className, BaseClauseAST * baseClause ) 00617 { 00618 QPtrList<BaseSpecifierAST> l = baseClause->baseSpecifierList(); 00619 QPtrListIterator<BaseSpecifierAST> it( l ); 00620 while( it.current() ){ 00621 BaseSpecifierAST* baseSpecifier = it.current(); 00622 00623 QString access; 00624 if( baseSpecifier->access() ) 00625 access = baseSpecifier->access()->text(); 00626 bool isVirtual = baseSpecifier->isVirtual() != 0; 00627 00628 QString baseName; 00629 00630 QPtrList<ClassOrNamespaceNameAST> l = baseSpecifier->name()->classOrNamespaceNameList(); 00631 QPtrListIterator<ClassOrNamespaceNameAST> nameIt( l ); 00632 while( nameIt.current() ){ 00633 if( nameIt.current()->name() ){ 00634 baseName += nameIt.current()->name()->text() + "::"; 00635 } 00636 ++nameIt; 00637 } 00638 00639 if( baseSpecifier->name()->unqualifiedName() && baseSpecifier->name()->unqualifiedName()->name() ) 00640 baseName += baseSpecifier->name()->unqualifiedName()->name()->text(); 00641 00642 Tag tag; 00643 CppBaseClass<Tag> tagBuilder( tag ); 00644 00645 tag.setKind( Tag::Kind_Base_class ); 00646 tag.setFileName( m_fileName ); 00647 tag.setName( className ); 00648 tag.setScope( m_currentScope ); 00649 00650 tagBuilder.setBaseClass( baseName ); 00651 tagBuilder.setVirtual( isVirtual ); 00652 tagBuilder.setAccess( TagUtils::stringToAccess(access) ); 00653 00654 m_catalog->addItem( tag ); 00655 00656 int line, col; 00657 baseClause->getStartPosition( &line, &col ); 00658 tag.setStartPosition( line, col ); 00659 00660 baseClause->getEndPosition( &line, &col ); 00661 tag.setEndPosition( line, col ); 00662 00663 ++it; 00664 } 00665 } 00666 00667 QString TagCreator::scopeOfDeclarator( DeclaratorAST* d ) 00668 { 00669 QStringList scope = m_currentScope; 00670 if( d && d->declaratorId() && d->declaratorId()->classOrNamespaceNameList().count() ){ 00671 if( d->declaratorId()->isGlobal() ) 00672 scope.clear(); 00673 QPtrList<ClassOrNamespaceNameAST> l = d->declaratorId()->classOrNamespaceNameList(); 00674 QPtrListIterator<ClassOrNamespaceNameAST> it( l ); 00675 while( it.current() ){ 00676 if( it.current()->name() ){ 00677 scope << it.current()->name()->text(); 00678 } 00679 ++it; 00680 } 00681 } 00682 00683 return scope.join( "." ); 00684 } 00685 00686 int TagUtils::stringToAccess( const QString & access ) 00687 { 00688 QStringList l = QStringList() 00689 << "public" << "protected" << "private" 00690 << "public slots" << "protected slots" << "private slots" 00691 << "signals"; 00692 00693 int idx = l.findIndex( access ); 00694 return idx == -1 ? 0 : idx+1; 00695 } 00696 00697 QString TagUtils::accessToString( int id ) 00698 { 00699 QStringList l = QStringList() 00700 << "public" << "protected" << "private" 00701 << "public slots" << "protected slots" << "private slots" 00702 << "signals"; 00703 00704 if( l.at(id-1) != l.end() ) 00705 return l[ id-1 ]; 00706 00707 return QString::null; 00708 }
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