KDevelop API Documentation

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.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:47 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003