doxyapp.cpp File Reference

Example of how to use doxygen as part of another GPL applications. More...

#include <stdlib.h>
#include <qfile.h>
#include <qdir.h>
#include "doxygen.h"
#include "outputgen.h"
#include "parserintf.h"
#include "classdef.h"
#include "namespacedef.h"
#include "filedef.h"
#include "util.h"
#include "classlist.h"
#include "config.h"
#include "filename.h"

Go to the source code of this file.

Classes
class	XRefDummyCodeGenerator

Functions
static void	findXRefSymbols (FileDef *fd)
static void	listSymbol (Definition *d)
static void	listSymbols ()
static void	lookupSymbol (Definition *d)
static void	lookupSymbols (const QCString &sym)
int	main (int argc, char **argv)

Detailed Description

Example of how to use doxygen as part of another GPL applications.

This example shows how to configure and run doxygen programmatically from within an application without generating the usual output. The example should work on any Unix like OS (including Linux and Mac OS X).

This example shows how to use to code parser to get cross-references information and it also shows how to look up symbols in a program parsed by doxygen and show some information about them.

Definition in file doxyapp.cpp.

Function Documentation

static void findXRefSymbols ( FileDef *  fd )

static

Definition at line 109 of file doxyapp.cpp.

{
  // get the interface to a parser that matches the file extension
  ParserInterface *pIntf=Doxygen::parserManager->getParser(fd->getDefFileExtension());

  // get the programming language from the file name
  SrcLangExt lang = getLanguageFromFileName(fd->name());

  // reset the parsers state
  pIntf->resetCodeParserState();

  // create a new backend object 
  XRefDummyCodeGenerator *xrefGen = new XRefDummyCodeGenerator(fd);

  // parse the source code
  pIntf->parseCode(*xrefGen,
                0,
                fileToString(fd->absFilePath()),
                lang,
                FALSE,
                0,
                fd);

  // dismiss the object.
  delete xrefGen;
}

static void listSymbol ( Definition *  d )

static

Definition at line 136 of file doxyapp.cpp.

{
  if (d!=Doxygen::globalScope && // skip the global namespace symbol
      d->name().at(0)!='@'       // skip anonymous stuff
     )      
  {
    printf("%s\n",
        d->name().data());
  }
}

static void listSymbols ( )

static

Definition at line 147 of file doxyapp.cpp.

{
  QDictIterator<DefinitionIntf> sli(*Doxygen::symbolMap);
  DefinitionIntf *di;
  for (sli.toFirst();(di=sli.current());++sli)
  {
    if (di->definitionType()==DefinitionIntf::TypeSymbolList) // list of symbols
      // with same name
    {
      DefinitionListIterator dli(*(DefinitionList*)di);
      Definition *d;
      // for each symbol
      for (dli.toFirst();(d=dli.current());++dli)
      {
        listSymbol(d);
      }
    }
    else // single symbol
    {
      listSymbol((Definition*)di);
    }
  }
}

static void lookupSymbol ( Definition *  d )

static

Definition at line 171 of file doxyapp.cpp.

{
  if (d!=Doxygen::globalScope && // skip the global namespace symbol
      d->name().at(0)!='@'       // skip anonymous stuff
     )      
  {
    printf("Symbol info\n");
    printf("-----------\n");
    printf("Name: %s\n",d->name().data());
    printf("File: %s\n",d->getDefFileName().data());
    printf("Line: %d\n",d->getDefLine());
    // depending on the definition type we can case to the appropriate
    // derived to get additional information
    switch (d->definitionType())
    {
      case Definition::TypeClass:
        {
          ClassDef *cd = (ClassDef *)d;
          printf("Kind: %s\n",cd->compoundTypeString().data());
        }
        break;
      case Definition::TypeFile:
        {
          FileDef *fd = (FileDef *)d;
          printf("Kind: File: #includes %d other files\n",
              fd->includeFileList() ? fd->includeFileList()->count() : 0);
        }
        break;
      case Definition::TypeNamespace:
        {
          NamespaceDef *nd = (NamespaceDef *)d;
          printf("Kind: Namespace: contains %d classes and %d namespaces\n",
              nd->getClassSDict() ? nd->getClassSDict()->count() : 0,
              nd->getNamespaceSDict() ? nd->getNamespaceSDict()->count() : 0);
        }
        break;
      case Definition::TypeMember:
        {
          MemberDef *md = (MemberDef *)d;
          printf("Kind: %s\n",md->memberTypeName().data());
        }
        break;
      default:
        // ignore groups/pages/packages/dirs for now
        break;
    }
  }
}

static void lookupSymbols ( const QCString &  sym )

static

Definition at line 220 of file doxyapp.cpp.

{
  if (!sym.isEmpty())
  {
    DefinitionIntf *di = Doxygen::symbolMap->find(sym);
    if (di)
    {
      if (di->definitionType()==DefinitionIntf::TypeSymbolList)
      {
        DefinitionListIterator dli(*(DefinitionList*)di);
        Definition *d;
        // for each symbol with the given name
        for (dli.toFirst();(d=dli.current());++dli)
        {
          lookupSymbol(d);
        }
      }
      else
      {
        lookupSymbol((Definition*)di);
      }
    }
    else
    {
      printf("Unknown symbol\n");
    }
  }
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 249 of file doxyapp.cpp.

{
  char cmd[256];

  if (argc<2)
  {
    printf("Usage: %s [source_file | source_dir]\n",argv[0]);
    exit(1);
  }

  // initialize data structures 
  initDoxygen();

  // setup the non-default configuration options

  // we need a place to put intermediate files
  Config_getString("OUTPUT_DIRECTORY")="/tmp/doxygen"; 
  // disable html output
  Config_getBool("GENERATE_HTML")=FALSE;
  // disable latex output
  Config_getBool("GENERATE_LATEX")=FALSE;
  // be quiet
  Config_getBool("QUIET")=TRUE;
  // turn off warnings
  Config_getBool("WARNINGS")=FALSE;
  Config_getBool("WARN_IF_UNDOCUMENTED")=FALSE;
  Config_getBool("WARN_IF_DOC_ERROR")=FALSE;
  // Extract as much as possible
  Config_getBool("EXTRACT_ALL")=TRUE;
  Config_getBool("EXTRACT_STATIC")=TRUE;
  Config_getBool("EXTRACT_PRIVATE")=TRUE;
  Config_getBool("EXTRACT_LOCAL_METHODS")=TRUE;
  // Extract source browse information, needed 
  // to make doxygen gather the cross reference info
  Config_getBool("SOURCE_BROWSER")=TRUE;

  // set the input
  Config_getList("INPUT").append(argv[1]);

  // check and finialize the configuration
  checkConfiguration();
  adjustConfiguration();

  // parse the files
  parseInput();

  // iterate over the input files
  FileNameListIterator fnli(*Doxygen::inputNameList); 
  FileName *fn;
  // foreach file with a certain name
  for (fnli.toFirst();(fn=fnli.current());++fnli)
  {
    FileNameIterator fni(*fn);
    FileDef *fd;
    // for each file definition
    for (;(fd=fni.current());++fni)
    {
      // get the references (linked and unlinked) found in this file
      findXRefSymbols(fd);
    }
  }

  // remove temporary files
  if (!Doxygen::objDBFileName.isEmpty()) QFile::remove(Doxygen::objDBFileName);
  if (!Doxygen::entryDBFileName.isEmpty()) QFile::remove(Doxygen::entryDBFileName);
  // clean up after us
  QDir().rmdir("/tmp/doxygen");

  while (1)
  {
    printf("> Type a symbol name or\n> .list for a list of symbols or\n> .quit to exit\n> ");
    fgets(cmd,256,stdin);
    QCString s(cmd);
    if (s.at(s.length()-1)=='\n') s=s.left(s.length()-1); // strip trailing \n
    if (s==".list") 
      listSymbols();
    else if (s==".quit") 
      exit(0);
    else 
      lookupSymbols(s);
  }
}