doxygen.h File Reference

#include <mutex>
#include "containers.h"
#include "membergroup.h"
#include "dirdef.h"
#include "memberlist.h"
#include "define.h"
#include "cache.h"
#include "symbolmap.h"
#include "searchindex.h"

Include dependency graph for doxygen.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	LookupInfo
struct	InputFileEncoding
struct	NamespaceAliasInfo
class	Doxygen
	This class serves as a namespace for global variables used by doxygen. More...

Macros
#define	THREAD_LOCAL   thread_local
#define	AtomicInt   std::atomic_int

Typedefs
using	InputFileEncodingList = std::vector<InputFileEncoding>
using	ClangUsrMap = std::unordered_map<std::string,const Definition *>
using	StaticInitMap = std::unordered_map<std::string,BodyInfo>
using	NamespaceAliasInfoMap = std::unordered_map<std::string,NamespaceAliasInfo>

Functions
void	initDoxygen ()
void	readConfiguration (int argc, char **argv)
void	checkConfiguration ()
	check and resolve config options
void	adjustConfiguration ()
	adjust globals that depend on configuration settings.
void	parseInput ()
void	generateOutput ()
void	cleanUpDoxygen ()
void	readFileOrDirectory (const QCString &s, FileNameLinkedMap *fnDict, StringUnorderedSet *exclSet, const StringVector *patList, const StringVector *exclPatList, StringVector *resultList, StringUnorderedSet *resultSet, bool recursive, bool errorIfNotExist=TRUE, StringUnorderedSet *killSet=nullptr, StringUnorderedSet *paths=nullptr)

Macro Definition Documentation

AtomicInt

#define AtomicInt   std::atomic_int

Definition at line 31 of file doxygen.h.

THREAD_LOCAL

#define THREAD_LOCAL   thread_local

Definition at line 30 of file doxygen.h.

Referenced by LatexCodeGenerator::codify(), and removeRedundantWhiteSpace().

Typedef Documentation

ClangUsrMap

using ClangUsrMap = std::unordered_map<std::string,const Definition *>

Definition at line 82 of file doxygen.h.

InputFileEncodingList

using InputFileEncodingList = std::vector<InputFileEncoding>

Definition at line 80 of file doxygen.h.

NamespaceAliasInfoMap

using NamespaceAliasInfoMap = std::unordered_map<std::string,NamespaceAliasInfo>

Definition at line 86 of file doxygen.h.

StaticInitMap

using StaticInitMap = std::unordered_map<std::string,BodyInfo>

Definition at line 84 of file doxygen.h.

Function Documentation

adjustConfiguration()

void adjustConfiguration

(

)

adjust globals that depend on configuration settings.

Definition at line 12012 of file doxygen.cpp.

{
  AUTO_TRACE();
  Doxygen::globalNamespaceDef = createNamespaceDef("<globalScope>",1,1,"<globalScope>");
  Doxygen::globalScope = toNamespaceDefMutable(Doxygen::globalNamespaceDef.get());
  Doxygen::inputNameLinkedMap = new FileNameLinkedMap;
  Doxygen::includeNameLinkedMap = new FileNameLinkedMap;
  Doxygen::exampleNameLinkedMap = new FileNameLinkedMap;
  Doxygen::imageNameLinkedMap = new FileNameLinkedMap;
  Doxygen::dotFileNameLinkedMap = new FileNameLinkedMap;
  Doxygen::mscFileNameLinkedMap = new FileNameLinkedMap;
  Doxygen::diaFileNameLinkedMap = new FileNameLinkedMap;
  Doxygen::plantUmlFileNameLinkedMap = new FileNameLinkedMap;
 
  setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
 
  /* Set the global html file extension. */
  Doxygen::htmlFileExtension = Config_getString(HTML_FILE_EXTENSION);
 
 
  Doxygen::parseSourcesNeeded = Config_getBool(CALL_GRAPH) ||
                                Config_getBool(CALLER_GRAPH) ||
                                Config_getBool(REFERENCES_RELATION) ||
                                Config_getBool(REFERENCED_BY_RELATION);
 
  /**************************************************************************
   *            Add custom extension mappings
   **************************************************************************/
 
  const StringVector &extMaps = Config_getList(EXTENSION_MAPPING);
  for (const auto &mapping : extMaps)
  {
    QCString mapStr = mapping;
    int i=mapStr.find('=');
    if (i==-1)
    {
      continue;
    }
    else
    {
      QCString ext = mapStr.left(i).stripWhiteSpace().lower();
      QCString language = mapStr.mid(i+1).stripWhiteSpace().lower();
      if (ext.isEmpty() || language.isEmpty())
      {
        continue;
      }
 
      if (!updateLanguageMapping(ext,language))
      {
        err("Failed to map file extension '{}' to unsupported language '{}'.\n"
            "Check the EXTENSION_MAPPING setting in the config file.\n",
            ext,language);
      }
      else
      {
        msg("Adding custom extension mapping: '{}' will be treated as language '{}'\n",
            ext,language);
      }
    }
  }
  // create input file exncodings
 
  // check INPUT_ENCODING
  void *cd = portable_iconv_open("UTF-8",Config_getString(INPUT_ENCODING).data());
  if (cd==reinterpret_cast<void *>(-1))
  {
    term("unsupported character conversion: '{}'->'UTF-8': {}\n"
        "Check the 'INPUT_ENCODING' setting in the config file!\n",
        Config_getString(INPUT_ENCODING),strerror(errno));
  }
  else
  {
    portable_iconv_close(cd);
  }
 
  // check and split INPUT_FILE_ENCODING
  const StringVector &fileEncod = Config_getList(INPUT_FILE_ENCODING);
  for (const auto &mapping : fileEncod)
  {
    QCString mapStr = mapping;
    int i=mapStr.find('=');
    if (i==-1)
    {
      continue;
    }
    else
    {
      QCString pattern = mapStr.left(i).stripWhiteSpace().lower();
      QCString encoding = mapStr.mid(i+1).stripWhiteSpace().lower();
      if (pattern.isEmpty() || encoding.isEmpty())
      {
        continue;
      }
      cd = portable_iconv_open("UTF-8",encoding.data());
      if (cd==reinterpret_cast<void *>(-1))
      {
        term("unsupported character conversion: '{}'->'UTF-8': {}\n"
            "Check the 'INPUT_FILE_ENCODING' setting in the config file!\n",
            encoding,strerror(errno));
      }
      else
      {
        portable_iconv_close(cd);
      }
 
      Doxygen::inputFileEncodingList.emplace_back(pattern, encoding);
    }
  }
 
  // add predefined macro name to a dictionary
  const StringVector &expandAsDefinedList =Config_getList(EXPAND_AS_DEFINED);
  for (const auto &s : expandAsDefinedList)
  {
    Doxygen::expandAsDefinedSet.insert(s);
  }
 
  // read aliases and store them in a dictionary
  readAliases();
 
  // store number of spaces in a tab into Doxygen::spaces
  int tabSize = Config_getInt(TAB_SIZE);
  Doxygen::spaces.resize(tabSize);
  for (int sp=0; sp<tabSize; sp++) Doxygen::spaces.at(sp)=' ';
  Doxygen::spaces.at(tabSize)='\0';
}

References AUTO_TRACE, Config_getBool, Config_getEnum, Config_getInt, Config_getList, Config_getString, createNamespaceDef(), QCString::data(), Doxygen::diaFileNameLinkedMap, Doxygen::dotFileNameLinkedMap, err, Doxygen::exampleNameLinkedMap, Doxygen::expandAsDefinedSet, QCString::find(), Doxygen::globalNamespaceDef, Doxygen::globalScope, Doxygen::htmlFileExtension, Doxygen::imageNameLinkedMap, Doxygen::includeNameLinkedMap, Doxygen::inputFileEncodingList, Doxygen::inputNameLinkedMap, QCString::isEmpty(), QCString::left(), QCString::lower(), QCString::mid(), Doxygen::mscFileNameLinkedMap, msg, Doxygen::parseSourcesNeeded, Doxygen::plantUmlFileNameLinkedMap, portable_iconv_close(), portable_iconv_open(), readAliases(), setTranslator(), Doxygen::spaces, QCString::stripWhiteSpace(), term, toNamespaceDefMutable(), and updateLanguageMapping().

Referenced by main().

checkConfiguration()

void checkConfiguration

(

)

check and resolve config options

Definition at line 12001 of file doxygen.cpp.

{
  AUTO_TRACE();
 
  Config::postProcess(FALSE);
  Config::updateObsolete();
  Config::checkAndCorrect(Config_getBool(QUIET), true);
  initWarningFormat();
}

References AUTO_TRACE, Config::checkAndCorrect(), Config_getBool, FALSE, initWarningFormat(), Config::postProcess(), and Config::updateObsolete().

Referenced by main().

cleanUpDoxygen()

void cleanUpDoxygen

(

)

Definition at line 11523 of file doxygen.cpp.

{
  FormulaManager::instance().clear();
  SectionManager::instance().clear();
  ModuleManager::instance().clear();
 
  delete Doxygen::indexList;
  delete Doxygen::inputNameLinkedMap;
  delete Doxygen::includeNameLinkedMap;
  delete Doxygen::exampleNameLinkedMap;
  delete Doxygen::imageNameLinkedMap;
  delete Doxygen::dotFileNameLinkedMap;
  delete Doxygen::mscFileNameLinkedMap;
  delete Doxygen::diaFileNameLinkedMap;
  delete Doxygen::plantUmlFileNameLinkedMap;
  Doxygen::mainPage.reset();
  delete Doxygen::pageLinkedMap;
  delete Doxygen::exampleLinkedMap;
  Doxygen::globalNamespaceDef.reset();
  Doxygen::globalScope = nullptr;
  delete Doxygen::parserManager;
  delete theTranslator;
  delete g_outputList;
 
  delete Doxygen::memberNameLinkedMap;
  delete Doxygen::functionNameLinkedMap;
  delete Doxygen::groupLinkedMap;
  delete Doxygen::namespaceLinkedMap;
  delete Doxygen::dirLinkedMap;
  delete Doxygen::symbolMap;
}

References FormulaManager::clear(), LinkedMap< T, Hash, KeyEqual, Map >::clear(), ModuleManager::clear(), Doxygen::diaFileNameLinkedMap, Doxygen::dirLinkedMap, Doxygen::dotFileNameLinkedMap, Doxygen::exampleLinkedMap, Doxygen::exampleNameLinkedMap, Doxygen::functionNameLinkedMap, g_outputList, Doxygen::globalNamespaceDef, Doxygen::globalScope, Doxygen::groupLinkedMap, Doxygen::imageNameLinkedMap, Doxygen::includeNameLinkedMap, Doxygen::indexList, Doxygen::inputNameLinkedMap, FormulaManager::instance(), ModuleManager::instance(), SectionManager::instance(), Doxygen::mainPage, Doxygen::memberNameLinkedMap, Doxygen::mscFileNameLinkedMap, Doxygen::namespaceLinkedMap, Doxygen::pageLinkedMap, Doxygen::parserManager, Doxygen::plantUmlFileNameLinkedMap, Doxygen::symbolMap, and theTranslator.

Referenced by generateOutput(), parseInput(), readConfiguration(), and stopDoxygen().

generateOutput()

void generateOutput

(

)

add extra languages for which we can only produce syntax highlighted code

Definition at line 13188 of file doxygen.cpp.

{
  AUTO_TRACE();
  /**************************************************************************
   *            Initialize output generators                                *
   **************************************************************************/
 
  /// add extra languages for which we can only produce syntax highlighted code
  addCodeOnlyMappings();
 
  //// dump all symbols
  if (g_dumpSymbolMap)
  {
    dumpSymbolMap();
    exit(0);
  }
 
  bool generateHtml  = Config_getBool(GENERATE_HTML);
  bool generateLatex = Config_getBool(GENERATE_LATEX);
  bool generateMan   = Config_getBool(GENERATE_MAN);
  bool generateRtf   = Config_getBool(GENERATE_RTF);
  bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
 
 
  g_outputList = new OutputList;
  if (generateHtml)
  {
    g_outputList->add<HtmlGenerator>();
    HtmlGenerator::init();
    HtmlGenerator::writeTabData();
  }
  if (generateLatex)
  {
    g_outputList->add<LatexGenerator>();
    LatexGenerator::init();
  }
  if (generateDocbook)
  {
    g_outputList->add<DocbookGenerator>();
    DocbookGenerator::init();
  }
  if (generateMan)
  {
    g_outputList->add<ManGenerator>();
    ManGenerator::init();
  }
  if (generateRtf)
  {
    g_outputList->add<RTFGenerator>();
    RTFGenerator::init();
  }
  if (Config_getBool(USE_HTAGS))
  {
    Htags::useHtags = TRUE;
    QCString htmldir = Config_getString(HTML_OUTPUT);
    if (!Htags::execute(htmldir))
       err("USE_HTAGS is YES but htags(1) failed. \n");
    else if (!Htags::loadFilemap(htmldir))
       err("htags(1) ended normally but failed to load the filemap. \n");
  }
 
  /**************************************************************************
   *                        Generate documentation                          *
   **************************************************************************/
 
  g_s.begin("Generating style sheet...\n");
  //printf("writing style info\n");
  g_outputList->writeStyleInfo(0); // write first part
  g_s.end();
 
  bool searchEngine      = Config_getBool(SEARCHENGINE);
  bool serverBasedSearch = Config_getBool(SERVER_BASED_SEARCH);
 
  g_s.begin("Generating search indices...\n");
  if (searchEngine && !serverBasedSearch && generateHtml)
  {
    createJavaScriptSearchIndex();
  }
 
  // generate search indices (need to do this before writing other HTML
  // pages as these contain a drop down menu with options depending on
  // what categories we find in this function.
  if (generateHtml && searchEngine)
  {
    QCString searchDirName = Config_getString(HTML_OUTPUT)+"/search";
    Dir searchDir(searchDirName.str());
    if (!searchDir.exists() && !searchDir.mkdir(searchDirName.str()))
    {
      term("Could not create search results directory '{}' $PWD='{}'\n",
          searchDirName,Dir::currentDirPath());
    }
    HtmlGenerator::writeSearchData(searchDirName);
    if (!serverBasedSearch) // client side search index
    {
      writeJavaScriptSearchIndex();
    }
  }
  g_s.end();
 
  // copy static stuff
  if (generateHtml)
  {
    copyStyleSheet();
    copyLogo(Config_getString(HTML_OUTPUT));
    copyIcon(Config_getString(HTML_OUTPUT));
    copyExtraFiles(Config_getList(HTML_EXTRA_FILES),"HTML_EXTRA_FILES",Config_getString(HTML_OUTPUT));
  }
  if (generateLatex)
  {
    copyLatexStyleSheet();
    copyLogo(Config_getString(LATEX_OUTPUT));
    copyIcon(Config_getString(LATEX_OUTPUT));
    copyExtraFiles(Config_getList(LATEX_EXTRA_FILES),"LATEX_EXTRA_FILES",Config_getString(LATEX_OUTPUT));
  }
  if (generateDocbook)
  {
    copyLogo(Config_getString(DOCBOOK_OUTPUT));
    copyIcon(Config_getString(DOCBOOK_OUTPUT));
  }
  if (generateRtf)
  {
    copyLogo(Config_getString(RTF_OUTPUT));
    copyIcon(Config_getString(RTF_OUTPUT));
    copyExtraFiles(Config_getList(RTF_EXTRA_FILES),"RTF_EXTRA_FILES",Config_getString(RTF_OUTPUT));
  }
 
  FormulaManager &fm = FormulaManager::instance();
  if (fm.hasFormulas() && generateHtml
      && !Config_getBool(USE_MATHJAX))
  {
    g_s.begin("Generating images for formulas in HTML...\n");
    fm.generateImages(Config_getString(HTML_OUTPUT), Config_getEnum(HTML_FORMULA_FORMAT)==HTML_FORMULA_FORMAT_t::svg ?
        FormulaManager::Format::Vector : FormulaManager::Format::Bitmap, FormulaManager::HighDPI::On);
    g_s.end();
  }
  if (fm.hasFormulas() && generateRtf)
  {
    g_s.begin("Generating images for formulas in RTF...\n");
    fm.generateImages(Config_getString(RTF_OUTPUT),FormulaManager::Format::Bitmap);
    g_s.end();
  }
 
  if (fm.hasFormulas() && generateDocbook)
  {
    g_s.begin("Generating images for formulas in Docbook...\n");
    fm.generateImages(Config_getString(DOCBOOK_OUTPUT),FormulaManager::Format::Bitmap);
    g_s.end();
  }
 
  g_s.begin("Generating example documentation...\n");
  generateExampleDocs();
  g_s.end();
 
  g_s.begin("Generating file sources...\n");
  generateFileSources();
  g_s.end();
 
  g_s.begin("Generating file documentation...\n");
  generateFileDocs();
  g_s.end();
 
  g_s.begin("Generating page documentation...\n");
  generatePageDocs();
  g_s.end();
 
  g_s.begin("Generating group documentation...\n");
  generateGroupDocs();
  g_s.end();
 
  g_s.begin("Generating class documentation...\n");
  generateClassDocs();
  g_s.end();
 
  g_s.begin("Generating concept documentation...\n");
  generateConceptDocs();
  g_s.end();
 
  g_s.begin("Generating module documentation...\n");
  ModuleManager::instance().writeDocumentation(*g_outputList);
  g_s.end();
 
  g_s.begin("Generating namespace documentation...\n");
  generateNamespaceDocs();
  g_s.end();
 
  if (Config_getBool(GENERATE_LEGEND))
  {
    g_s.begin("Generating graph info page...\n");
    writeGraphInfo(*g_outputList);
    g_s.end();
  }
 
  g_s.begin("Generating directory documentation...\n");
  generateDirDocs(*g_outputList);
  g_s.end();
 
  if (g_outputList->size()>0)
  {
    writeIndexHierarchy(*g_outputList);
  }
 
  g_s.begin("finalizing index lists...\n");
  Doxygen::indexList->finalize();
  g_s.end();
 
  g_s.begin("writing tag file...\n");
  writeTagFile();
  g_s.end();
 
  if (Config_getBool(GENERATE_XML))
  {
    g_s.begin("Generating XML output...\n");
    Doxygen::generatingXmlOutput=TRUE;
    generateXML();
    Doxygen::generatingXmlOutput=FALSE;
    g_s.end();
  }
  if (Config_getBool(GENERATE_SQLITE3))
  {
    g_s.begin("Generating SQLITE3 output...\n");
    generateSqlite3();
    g_s.end();
  }
 
  if (Config_getBool(GENERATE_AUTOGEN_DEF))
  {
    g_s.begin("Generating AutoGen DEF output...\n");
    generateDEF();
    g_s.end();
  }
  if (Config_getBool(GENERATE_PERLMOD))
  {
    g_s.begin("Generating Perl module output...\n");
    generatePerlMod();
    g_s.end();
  }
  if (generateHtml && searchEngine && serverBasedSearch)
  {
    g_s.begin("Generating search index\n");
    if (Doxygen::searchIndex.kind()==SearchIndexIntf::Internal) // write own search index
    {
      HtmlGenerator::writeSearchPage();
      Doxygen::searchIndex.write(Config_getString(HTML_OUTPUT)+"/search/search.idx");
    }
    else // write data for external search index
    {
      HtmlGenerator::writeExternalSearchPage();
      QCString searchDataFile = Config_getString(SEARCHDATA_FILE);
      if (searchDataFile.isEmpty())
      {
        searchDataFile="searchdata.xml";
      }
      if (!Portable::isAbsolutePath(searchDataFile.data()))
      {
        searchDataFile.prepend(Config_getString(OUTPUT_DIRECTORY)+"/");
      }
      Doxygen::searchIndex.write(searchDataFile);
    }
    g_s.end();
  }
 
  if (generateRtf)
  {
    g_s.begin("Combining RTF output...\n");
    if (!RTFGenerator::preProcessFileInplace(Config_getString(RTF_OUTPUT),"refman.rtf"))
    {
      err("An error occurred during post-processing the RTF files!\n");
    }
    g_s.end();
  }
 
  g_s.begin("Running plantuml with JAVA...\n");
  PlantumlManager::instance().run();
  g_s.end();
 
  if (Config_getBool(HAVE_DOT))
  {
    g_s.begin("Running dot...\n");
    DotManager::instance()->run();
    g_s.end();
  }
 
  if (generateHtml &&
      Config_getBool(GENERATE_HTMLHELP) &&
      !Config_getString(HHC_LOCATION).isEmpty())
  {
    g_s.begin("Running html help compiler...\n");
    runHtmlHelpCompiler();
    g_s.end();
  }
 
  if ( generateHtml &&
       Config_getBool(GENERATE_QHP) &&
      !Config_getString(QHG_LOCATION).isEmpty())
  {
    g_s.begin("Running qhelpgenerator...\n");
    runQHelpGenerator();
    g_s.end();
  }
 
  g_outputList->cleanup();
  cleanupInlineGraph();
 
  msg("type lookup cache used {}/{} hits={} misses={}\n",
      Doxygen::typeLookupCache->size(),
      Doxygen::typeLookupCache->capacity(),
      Doxygen::typeLookupCache->hits(),
      Doxygen::typeLookupCache->misses());
  msg("symbol lookup cache used {}/{} hits={} misses={}\n",
      Doxygen::symbolLookupCache->size(),
      Doxygen::symbolLookupCache->capacity(),
      Doxygen::symbolLookupCache->hits(),
      Doxygen::symbolLookupCache->misses());
  int typeCacheParam   = computeIdealCacheParam(static_cast<size_t>(Doxygen::typeLookupCache->misses()*2/3)); // part of the cache is flushed, hence the 2/3 correction factor
  int symbolCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::symbolLookupCache->misses()));
  int cacheParam = std::max(typeCacheParam,symbolCacheParam);
  if (cacheParam>Config_getInt(LOOKUP_CACHE_SIZE))
  {
    msg("Note: based on cache misses the ideal setting for LOOKUP_CACHE_SIZE is {} at the cost of higher memory usage.\n",cacheParam);
  }
 
  if (Debug::isFlagSet(Debug::Time))
  {
 
    std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
    if (numThreads<1) numThreads=1;
    msg("Total elapsed time: {:.6f} seconds\n(of which an average of {:.6f} seconds per thread waiting for external tools to finish)\n",
         (static_cast<double>(Debug::elapsedTime())),
         Portable::getSysElapsedTime()/static_cast<double>(numThreads)
        );
    g_s.print();
 
    Debug::clearFlag(Debug::Time);
    msg("finished...\n");
    Debug::setFlag(Debug::Time);
  }
  else
  {
    msg("finished...\n");
  }
 
 
  /**************************************************************************
   *                        Start cleaning up                               *
   **************************************************************************/
 
  cleanUpDoxygen();
 
  finalizeSearchIndexer();
  Dir thisDir;
  thisDir.remove(Doxygen::filterDBFileName.str());
  finishWarnExit();
  exitTracing();
  Config::deinit();
  delete Doxygen::clangUsrMap;
  g_successfulRun=TRUE;
 
  //dumpDocNodeSizes();
}

References addCodeOnlyMappings(), AUTO_TRACE, FormulaManager::Bitmap, Doxygen::clangUsrMap, cleanUpDoxygen(), cleanupInlineGraph(), Debug::clearFlag(), computeIdealCacheParam(), Config_getBool, Config_getEnum, Config_getInt, Config_getList, Config_getString, copyExtraFiles(), copyIcon(), copyLatexStyleSheet(), copyLogo(), copyStyleSheet(), createJavaScriptSearchIndex(), Dir::currentDirPath(), QCString::data(), Config::deinit(), dumpSymbolMap(), Debug::elapsedTime(), err, Htags::execute(), Dir::exists(), exitTracing(), FALSE, Doxygen::filterDBFileName, finalizeSearchIndexer(), finishWarnExit(), g_dumpSymbolMap, g_outputList, g_s, g_successfulRun, generateClassDocs(), generateConceptDocs(), generateDEF(), generateDirDocs(), generateExampleDocs(), generateFileDocs(), generateFileSources(), generateGroupDocs(), FormulaManager::generateImages(), generateNamespaceDocs(), generatePageDocs(), generatePerlMod(), generateSqlite3(), generateXML(), Doxygen::generatingXmlOutput, Portable::getSysElapsedTime(), FormulaManager::hasFormulas(), Doxygen::indexList, DocbookGenerator::init(), HtmlGenerator::init(), LatexGenerator::init(), ManGenerator::init(), RTFGenerator::init(), DotManager::instance(), FormulaManager::instance(), ModuleManager::instance(), PlantumlManager::instance(), SearchIndexIntf::Internal, Portable::isAbsolutePath(), QCString::isEmpty(), Debug::isFlagSet(), Htags::loadFilemap(), Dir::mkdir(), msg, FormulaManager::On, QCString::prepend(), RTFGenerator::preProcessFileInplace(), Dir::remove(), DotManager::run(), PlantumlManager::run(), runHtmlHelpCompiler(), runQHelpGenerator(), Doxygen::searchIndex, Debug::setFlag(), QCString::str(), Doxygen::symbolLookupCache, term, Debug::Time, TRUE, Doxygen::typeLookupCache, Htags::useHtags, FormulaManager::Vector, ModuleManager::writeDocumentation(), HtmlGenerator::writeExternalSearchPage(), writeGraphInfo(), writeIndexHierarchy(), writeJavaScriptSearchIndex(), HtmlGenerator::writeSearchData(), HtmlGenerator::writeSearchPage(), HtmlGenerator::writeTabData(), and writeTagFile().

Referenced by main().

initDoxygen()

void initDoxygen

(

)

Definition at line 11454 of file doxygen.cpp.

{
  initResources();
  QCString lang = Portable::getenv("LC_ALL");
  if (!lang.isEmpty()) Portable::setenv("LANG",lang);
  std::setlocale(LC_ALL,"");
  std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
  std::setlocale(LC_NUMERIC,"C");
 
  Doxygen::symbolMap = new SymbolMap<Definition>;
 
  Debug::startTimer();
  Doxygen::parserManager = new ParserManager(            make_parser_factory<NullOutlineParser>(),
                                                         make_parser_factory<FileCodeParser>());
  Doxygen::parserManager->registerParser("c",            make_parser_factory<COutlineParser>(),
                                                         make_parser_factory<CCodeParser>());
  Doxygen::parserManager->registerParser("python",       make_parser_factory<PythonOutlineParser>(),
                                                         make_parser_factory<PythonCodeParser>());
  Doxygen::parserManager->registerParser("fortran",      make_parser_factory<FortranOutlineParser>(),
                                                         make_parser_factory<FortranCodeParser>());
  Doxygen::parserManager->registerParser("fortranfree",  make_parser_factory<FortranOutlineParserFree>(),
                                                         make_parser_factory<FortranCodeParserFree>());
  Doxygen::parserManager->registerParser("fortranfixed", make_parser_factory<FortranOutlineParserFixed>(),
                                                         make_parser_factory<FortranCodeParserFixed>());
  Doxygen::parserManager->registerParser("vhdl",         make_parser_factory<VHDLOutlineParser>(),
                                                         make_parser_factory<VHDLCodeParser>());
  Doxygen::parserManager->registerParser("xml",          make_parser_factory<NullOutlineParser>(),
                                                         make_parser_factory<XMLCodeParser>());
  Doxygen::parserManager->registerParser("sql",          make_parser_factory<NullOutlineParser>(),
                                                         make_parser_factory<SQLCodeParser>());
  Doxygen::parserManager->registerParser("md",           make_parser_factory<MarkdownOutlineParser>(),
                                                         make_parser_factory<FileCodeParser>());
  Doxygen::parserManager->registerParser("lex",          make_parser_factory<LexOutlineParser>(),
                                                         make_parser_factory<LexCodeParser>());
 
  // register any additional parsers here...
 
  initDefaultExtensionMapping();
 
#if USE_LIBCLANG
  Doxygen::clangUsrMap   = new ClangUsrMap;
#endif
  Doxygen::memberNameLinkedMap = new MemberNameLinkedMap;
  Doxygen::functionNameLinkedMap = new MemberNameLinkedMap;
  Doxygen::groupLinkedMap = new GroupLinkedMap;
  Doxygen::namespaceLinkedMap = new NamespaceLinkedMap;
  Doxygen::classLinkedMap = new ClassLinkedMap;
  Doxygen::hiddenClassLinkedMap = new ClassLinkedMap;
  Doxygen::conceptLinkedMap = new ConceptLinkedMap;
  Doxygen::dirLinkedMap = new DirLinkedMap;
  Doxygen::pageLinkedMap = new PageLinkedMap;          // all doc pages
  Doxygen::exampleLinkedMap = new PageLinkedMap;       // all examples
  //Doxygen::tagDestinationDict.setAutoDelete(TRUE);
  Doxygen::indexList = new IndexList;
 
  // initialization of these globals depends on
  // configuration switches so we need to postpone these
  Doxygen::globalScope     = nullptr;
  Doxygen::inputNameLinkedMap   = nullptr;
  Doxygen::includeNameLinkedMap = nullptr;
  Doxygen::exampleNameLinkedMap = nullptr;
  Doxygen::imageNameLinkedMap   = nullptr;
  Doxygen::dotFileNameLinkedMap = nullptr;
  Doxygen::mscFileNameLinkedMap = nullptr;
  Doxygen::diaFileNameLinkedMap = nullptr;
  Doxygen::plantUmlFileNameLinkedMap = nullptr;
 
}

References Doxygen::clangUsrMap, Doxygen::classLinkedMap, Doxygen::conceptLinkedMap, Doxygen::diaFileNameLinkedMap, Doxygen::dirLinkedMap, Doxygen::dotFileNameLinkedMap, Doxygen::exampleLinkedMap, Doxygen::exampleNameLinkedMap, Doxygen::functionNameLinkedMap, Portable::getenv(), Doxygen::globalScope, Doxygen::groupLinkedMap, Doxygen::hiddenClassLinkedMap, Doxygen::imageNameLinkedMap, Doxygen::includeNameLinkedMap, Doxygen::indexList, initDefaultExtensionMapping(), initResources(), Doxygen::inputNameLinkedMap, QCString::isEmpty(), make_parser_factory(), Doxygen::memberNameLinkedMap, Doxygen::mscFileNameLinkedMap, Doxygen::namespaceLinkedMap, Doxygen::pageLinkedMap, Doxygen::parserManager, Doxygen::plantUmlFileNameLinkedMap, Portable::setenv(), Debug::startTimer(), and Doxygen::symbolMap.

Referenced by main().

parseInput()

void parseInput

(

)

Definition at line 12504 of file doxygen.cpp.

{
  AUTO_TRACE();
  std::atexit(exitDoxygen);
 
  Portable::correctPath(Config_getList(EXTERNAL_TOOL_PATH));
 
#if USE_LIBCLANG
  Doxygen::clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
#endif
 
  // we would like to show the versionString earlier, but we first have to handle the configuration file
  // to know the value of the QUIET setting.
  QCString versionString = getFullVersion();
  msg("Doxygen version used: {}\n",versionString);
 
  computeVerifiedDotPath();
 
  /**************************************************************************
   *            Make sure the output directory exists
   **************************************************************************/
  QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
  if (!g_singleComment)
  {
    if (outputDirectory.isEmpty())
    {
      outputDirectory = Config_updateString(OUTPUT_DIRECTORY,Dir::currentDirPath());
    }
    else
    {
      Dir dir(outputDirectory.str());
      if (!dir.exists())
      {
        dir.setPath(Dir::currentDirPath());
        if (!dir.mkdir(outputDirectory.str()))
        {
          term("tag OUTPUT_DIRECTORY: Output directory '{}' does not "
              "exist and cannot be created\n",outputDirectory);
        }
        else
        {
          msg("Notice: Output directory '{}' does not exist. "
              "I have created it for you.\n", outputDirectory);
        }
        dir.setPath(outputDirectory.str());
      }
      outputDirectory = Config_updateString(OUTPUT_DIRECTORY,dir.absPath());
    }
  }
  AUTO_TRACE_ADD("outputDirectory={}",outputDirectory);
 
  /**************************************************************************
   *            Initialize global lists and dictionaries
   **************************************************************************/
 
  // also scale lookup cache with SYMBOL_CACHE_SIZE
  int cacheSize = Config_getInt(LOOKUP_CACHE_SIZE);
  if (cacheSize<0) cacheSize=0;
  if (cacheSize>9) cacheSize=9;
  uint32_t lookupSize = 65536 << cacheSize;
  Doxygen::typeLookupCache = new Cache<std::string,LookupInfo>(lookupSize);
  Doxygen::symbolLookupCache = new Cache<std::string,LookupInfo>(lookupSize);
 
#ifdef HAS_SIGNALS
  signal(SIGINT, stopDoxygen);
#endif
 
  uint32_t pid = Portable::pid();
  Doxygen::filterDBFileName.sprintf("doxygen_filterdb_%d.tmp",pid);
  Doxygen::filterDBFileName.prepend(outputDirectory+"/");
 
  /**************************************************************************
   *            Check/create output directories                             *
   **************************************************************************/
 
  bool generateHtml    = Config_getBool(GENERATE_HTML);
  bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
  bool generateXml     = Config_getBool(GENERATE_XML);
  bool generateLatex   = Config_getBool(GENERATE_LATEX);
  bool generateRtf     = Config_getBool(GENERATE_RTF);
  bool generateMan     = Config_getBool(GENERATE_MAN);
  bool generateSql     = Config_getBool(GENERATE_SQLITE3);
  QCString htmlOutput;
  QCString docbookOutput;
  QCString xmlOutput;
  QCString latexOutput;
  QCString rtfOutput;
  QCString manOutput;
  QCString sqlOutput;
 
  if (!g_singleComment)
  {
    if (generateHtml)
    {
      htmlOutput = createOutputDirectory(outputDirectory,Config_getString(HTML_OUTPUT),"/html");
      Config_updateString(HTML_OUTPUT,htmlOutput);
 
      QCString sitemapUrl = Config_getString(SITEMAP_URL);
      bool generateSitemap = !sitemapUrl.isEmpty();
      if (generateSitemap && !sitemapUrl.endsWith("/"))
      {
        Config_updateString(SITEMAP_URL,sitemapUrl+"/");
      }
 
      // add HTML indexers that are enabled
      bool generateHtmlHelp    = Config_getBool(GENERATE_HTMLHELP);
      bool generateEclipseHelp = Config_getBool(GENERATE_ECLIPSEHELP);
      bool generateQhp         = Config_getBool(GENERATE_QHP);
      bool generateTreeView    = Config_getBool(GENERATE_TREEVIEW);
      bool generateDocSet      = Config_getBool(GENERATE_DOCSET);
      if (generateEclipseHelp) Doxygen::indexList->addIndex<EclipseHelp>();
      if (generateHtmlHelp)    Doxygen::indexList->addIndex<HtmlHelp>();
      if (generateQhp)         Doxygen::indexList->addIndex<Qhp>();
      if (generateSitemap)     Doxygen::indexList->addIndex<Sitemap>();
      if (generateTreeView)    Doxygen::indexList->addIndex<FTVHelp>(TRUE);
      if (generateDocSet)      Doxygen::indexList->addIndex<DocSets>();
      Doxygen::indexList->addIndex<Crawlmap>();
      Doxygen::indexList->initialize();
    }
 
    if (generateDocbook)
    {
      docbookOutput = createOutputDirectory(outputDirectory,Config_getString(DOCBOOK_OUTPUT),"/docbook");
      Config_updateString(DOCBOOK_OUTPUT,docbookOutput);
    }
 
    if (generateXml)
    {
      xmlOutput = createOutputDirectory(outputDirectory,Config_getString(XML_OUTPUT),"/xml");
      Config_updateString(XML_OUTPUT,xmlOutput);
    }
 
    if (generateLatex)
    {
      latexOutput = createOutputDirectory(outputDirectory,Config_getString(LATEX_OUTPUT), "/latex");
      Config_updateString(LATEX_OUTPUT,latexOutput);
    }
 
    if (generateRtf)
    {
      rtfOutput = createOutputDirectory(outputDirectory,Config_getString(RTF_OUTPUT),"/rtf");
      Config_updateString(RTF_OUTPUT,rtfOutput);
    }
 
    if (generateMan)
    {
      manOutput = createOutputDirectory(outputDirectory,Config_getString(MAN_OUTPUT),"/man");
      Config_updateString(MAN_OUTPUT,manOutput);
    }
 
    if (generateSql)
    {
      sqlOutput = createOutputDirectory(outputDirectory,Config_getString(SQLITE3_OUTPUT),"/sqlite3");
      Config_updateString(SQLITE3_OUTPUT,sqlOutput);
    }
  }
 
  if (Config_getBool(HAVE_DOT))
  {
    QCString curFontPath = Config_getString(DOT_FONTPATH);
    if (curFontPath.isEmpty())
    {
      Portable::getenv("DOTFONTPATH");
      QCString newFontPath = ".";
      if (!curFontPath.isEmpty())
      {
        newFontPath+=Portable::pathListSeparator();
        newFontPath+=curFontPath;
      }
      Portable::setenv("DOTFONTPATH",qPrint(newFontPath));
    }
    else
    {
      Portable::setenv("DOTFONTPATH",qPrint(curFontPath));
    }
  }
 
  /**************************************************************************
   *             Handle layout file                                         *
   **************************************************************************/
 
  LayoutDocManager::instance().init();
  QCString layoutFileName = Config_getString(LAYOUT_FILE);
  bool defaultLayoutUsed = FALSE;
  if (layoutFileName.isEmpty())
  {
    layoutFileName = Config_updateString(LAYOUT_FILE,"DoxygenLayout.xml");
    defaultLayoutUsed = TRUE;
  }
  AUTO_TRACE_ADD("defaultLayoutUsed={}, layoutFileName={}",defaultLayoutUsed,layoutFileName);
 
  FileInfo fi(layoutFileName.str());
  if (fi.exists())
  {
    msg("Parsing layout file {}...\n",layoutFileName);
    LayoutDocManager::instance().parse(layoutFileName);
  }
  else if (!defaultLayoutUsed)
  {
      warn_uncond("failed to open layout file '{}' for reading! Using default settings.\n",layoutFileName);
  }
  printLayout();
 
  /**************************************************************************
   *             Read and preprocess input                                  *
   **************************************************************************/
 
  // prevent search in the output directories
  StringVector exclPatterns = Config_getList(EXCLUDE_PATTERNS);
  if (generateHtml)    exclPatterns.push_back(htmlOutput.str());
  if (generateDocbook) exclPatterns.push_back(docbookOutput.str());
  if (generateXml)     exclPatterns.push_back(xmlOutput.str());
  if (generateLatex)   exclPatterns.push_back(latexOutput.str());
  if (generateRtf)     exclPatterns.push_back(rtfOutput.str());
  if (generateMan)     exclPatterns.push_back(manOutput.str());
  Config_updateList(EXCLUDE_PATTERNS,exclPatterns);
 
  if (!g_singleComment)
  {
    searchInputFiles();
 
    checkMarkdownMainfile();
  }
 
  // Notice: the order of the function calls below is very important!
 
  if (generateHtml && !Config_getBool(USE_MATHJAX))
  {
    FormulaManager::instance().initFromRepository(htmlOutput);
  }
  if (generateRtf)
  {
    FormulaManager::instance().initFromRepository(rtfOutput);
  }
  if (generateDocbook)
  {
    FormulaManager::instance().initFromRepository(docbookOutput);
  }
 
  FormulaManager::instance().checkRepositories();
 
  /**************************************************************************
   *             Handle Tag Files                                           *
   **************************************************************************/
 
  std::shared_ptr<Entry> root = std::make_shared<Entry>();
 
  if (!g_singleComment)
  {
    msg("Reading and parsing tag files\n");
    const StringVector &tagFileList = Config_getList(TAGFILES);
    for (const auto &s : tagFileList)
    {
      readTagFile(root,s.c_str());
    }
  }
 
  /**************************************************************************
   *             Parse source files                                         *
   **************************************************************************/
 
  addSTLSupport(root);
 
  g_s.begin("Parsing files\n");
  if (g_singleComment)
  {
    //printf("Parsing comment %s\n",qPrint(g_commentFileName));
    if (g_commentFileName=="-")
    {
      std::string text = fileToString(g_commentFileName).str();
      addTerminalCharIfMissing(text,'\n');
      generateHtmlForComment("stdin.md",text);
    }
    else if (FileInfo(g_commentFileName.str()).isFile())
    {
      std::string text;
      readInputFile(g_commentFileName,text);
      addTerminalCharIfMissing(text,'\n');
      generateHtmlForComment(g_commentFileName.str(),text);
    }
    else
    {
    }
    cleanUpDoxygen();
    exit(0);
  }
  else
  {
    if (Config_getInt(NUM_PROC_THREADS)==1)
    {
      parseFilesSingleThreading(root);
    }
    else
    {
      parseFilesMultiThreading(root);
    }
  }
  g_s.end();
 
  /**************************************************************************
   *             Gather information                                         *
   **************************************************************************/
 
  g_s.begin("Building macro definition list...\n");
  buildDefineList();
  g_s.end();
 
  g_s.begin("Building group list...\n");
  buildGroupList(root.get());
  organizeSubGroups(root.get());
  g_s.end();
 
  g_s.begin("Building directory list...\n");
  buildDirectories();
  findDirDocumentation(root.get());
  g_s.end();
 
  g_s.begin("Building namespace list...\n");
  buildNamespaceList(root.get());
  findUsingDirectives(root.get());
  g_s.end();
 
  g_s.begin("Building file list...\n");
  buildFileList(root.get());
  g_s.end();
 
  g_s.begin("Building class list...\n");
  buildClassList(root.get());
  g_s.end();
 
  g_s.begin("Building concept list...\n");
  buildConceptList(root.get());
  g_s.end();
 
  // build list of using declarations here (global list)
  buildListOfUsingDecls(root.get());
  g_s.end();
 
  g_s.begin("Computing nesting relations for classes...\n");
  resolveClassNestingRelations();
  g_s.end();
  // 1.8.2-20121111: no longer add nested classes to the group as well
  //distributeClassGroupRelations();
 
  // calling buildClassList may result in cached relations that
  // become invalid after resolveClassNestingRelations(), that's why
  // we need to clear the cache here
  Doxygen::typeLookupCache->clear();
  // we don't need the list of using declaration anymore
  g_usingDeclarations.clear();
 
  g_s.begin("Associating documentation with classes...\n");
  buildClassDocList(root.get());
  g_s.end();
 
  g_s.begin("Associating documentation with concepts...\n");
  buildConceptDocList(root.get());
  distributeConceptGroups();
  g_s.end();
 
  g_s.begin("Associating documentation with modules...\n");
  findModuleDocumentation(root.get());
  g_s.end();
 
  g_s.begin("Building example list...\n");
  buildExampleList(root.get());
  g_s.end();
 
  g_s.begin("Searching for enumerations...\n");
  findEnums(root.get());
  g_s.end();
 
  // Since buildVarList calls isVarWithConstructor
  // and this calls getResolvedClass we need to process
  // typedefs first so the relations between classes via typedefs
  // are properly resolved. See bug 536385 for an example.
  g_s.begin("Searching for documented typedefs...\n");
  buildTypedefList(root.get());
  g_s.end();
 
  if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
  {
    g_s.begin("Searching for documented sequences...\n");
    buildSequenceList(root.get());
    g_s.end();
 
    g_s.begin("Searching for documented dictionaries...\n");
    buildDictionaryList(root.get());
    g_s.end();
  }
 
  g_s.begin("Searching for members imported via using declarations...\n");
  // this should be after buildTypedefList in order to properly import
  // used typedefs
  findUsingDeclarations(root.get(),TRUE);  // do for python packages first
  findUsingDeclarations(root.get(),FALSE); // then the rest
  g_s.end();
 
  g_s.begin("Searching for included using directives...\n");
  findIncludedUsingDirectives();
  g_s.end();
 
  g_s.begin("Searching for documented variables...\n");
  buildVarList(root.get());
  g_s.end();
 
  g_s.begin("Building interface member list...\n");
  buildInterfaceAndServiceList(root.get()); // UNO IDL
 
  g_s.begin("Building member list...\n"); // using class info only !
  buildFunctionList(root.get());
  g_s.end();
 
  g_s.begin("Searching for friends...\n");
  findFriends();
  g_s.end();
 
  g_s.begin("Searching for documented defines...\n");
  findDefineDocumentation(root.get());
  g_s.end();
 
  g_s.begin("Computing class inheritance relations...\n");
  findClassEntries(root.get());
  findInheritedTemplateInstances();
  g_s.end();
 
  g_s.begin("Computing class usage relations...\n");
  findUsedTemplateInstances();
  g_s.end();
 
  if (Config_getBool(INLINE_SIMPLE_STRUCTS))
  {
    g_s.begin("Searching for tag less structs...\n");
    findTagLessClasses();
    g_s.end();
  }
 
  g_s.begin("Flushing cached template relations that have become invalid...\n");
  flushCachedTemplateRelations();
  g_s.end();
 
  g_s.begin("Warn for undocumented namespaces...\n");
  warnUndocumentedNamespaces();
  g_s.end();
 
  g_s.begin("Computing class relations...\n");
  computeTemplateClassRelations();
  flushUnresolvedRelations();
  if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
  {
    VhdlDocGen::computeVhdlComponentRelations();
  }
  computeClassRelations();
  g_classEntries.clear();
  g_s.end();
 
  g_s.begin("Add enum values to enums...\n");
  addEnumValuesToEnums(root.get());
  findEnumDocumentation(root.get());
  g_s.end();
 
  g_s.begin("Searching for member function documentation...\n");
  findObjCMethodDefinitions(root.get());
  findMemberDocumentation(root.get()); // may introduce new members !
  findUsingDeclImports(root.get()); // may introduce new members !
  g_usingClassMap.clear();
  transferRelatedFunctionDocumentation();
  transferFunctionDocumentation();
  transferStaticInstanceInitializers();
  g_s.end();
 
  // moved to after finding and copying documentation,
  // as this introduces new members see bug 722654
  g_s.begin("Creating members for template instances...\n");
  createTemplateInstanceMembers();
  g_s.end();
 
  g_s.begin("Building page list...\n");
  buildPageList(root.get());
  g_s.end();
 
  g_s.begin("Building requirements list...\n");
  buildRequirementsList(root.get());
  g_s.end();
 
  g_s.begin("Search for main page...\n");
  findMainPage(root.get());
  findMainPageTagFiles(root.get());
  g_s.end();
 
  g_s.begin("Computing page relations...\n");
  computePageRelations(root.get());
  checkPageRelations();
  g_s.end();
 
  g_s.begin("Determining the scope of groups...\n");
  findGroupScope(root.get());
  g_s.end();
 
  g_s.begin("Computing module relations...\n");
  auto &mm = ModuleManager::instance();
  mm.resolvePartitions();
  mm.resolveImports();
  mm.collectExportedSymbols();
  g_s.end();
 
  auto memberNameComp = [](const MemberNameLinkedMap::Ptr &n1,const MemberNameLinkedMap::Ptr &n2)
  {
    return qstricmp_sort(n1->memberName().data()+getPrefixIndex(n1->memberName()),
                         n2->memberName().data()+getPrefixIndex(n2->memberName())
                        )<0;
  };
 
  auto classComp = [](const ClassLinkedMap::Ptr &c1,const ClassLinkedMap::Ptr &c2)
  {
    if (Config_getBool(SORT_BY_SCOPE_NAME))
    {
      return qstricmp_sort(c1->name(), c2->name())<0;
    }
    else
    {
      int i = qstricmp_sort(c1->className(), c2->className());
      return i==0 ? qstricmp_sort(c1->name(), c2->name())<0 : i<0;
    }
  };
 
  auto namespaceComp = [](const NamespaceLinkedMap::Ptr &n1,const NamespaceLinkedMap::Ptr &n2)
  {
    return qstricmp_sort(n1->name(),n2->name())<0;
  };
 
  auto conceptComp = [](const ConceptLinkedMap::Ptr &c1,const ConceptLinkedMap::Ptr &c2)
  {
    return qstricmp_sort(c1->name(),c2->name())<0;
  };
 
  g_s.begin("Sorting lists...\n");
  std::stable_sort(Doxygen::memberNameLinkedMap->begin(),
            Doxygen::memberNameLinkedMap->end(),
            memberNameComp);
  std::stable_sort(Doxygen::functionNameLinkedMap->begin(),
            Doxygen::functionNameLinkedMap->end(),
            memberNameComp);
  std::stable_sort(Doxygen::hiddenClassLinkedMap->begin(),
            Doxygen::hiddenClassLinkedMap->end(),
            classComp);
  std::stable_sort(Doxygen::classLinkedMap->begin(),
            Doxygen::classLinkedMap->end(),
            classComp);
  std::stable_sort(Doxygen::conceptLinkedMap->begin(),
            Doxygen::conceptLinkedMap->end(),
            conceptComp);
  std::stable_sort(Doxygen::namespaceLinkedMap->begin(),
            Doxygen::namespaceLinkedMap->end(),
            namespaceComp);
  g_s.end();
 
  g_s.begin("Determining which enums are documented\n");
  findDocumentedEnumValues();
  g_s.end();
 
  g_s.begin("Computing member relations...\n");
  mergeCategories();
  computeMemberRelations();
  g_s.end();
 
  g_s.begin("Building full member lists recursively...\n");
  buildCompleteMemberLists();
  g_s.end();
 
  g_s.begin("Adding members to member groups.\n");
  addMembersToMemberGroup();
  g_s.end();
 
  if (Config_getBool(DISTRIBUTE_GROUP_DOC))
  {
    g_s.begin("Distributing member group documentation.\n");
    distributeMemberGroupDocumentation();
    g_s.end();
  }
 
  g_s.begin("Computing member references...\n");
  computeMemberReferences();
  g_s.end();
 
  if (Config_getBool(INHERIT_DOCS))
  {
    g_s.begin("Inheriting documentation...\n");
    inheritDocumentation();
    g_s.end();
  }
 
 
  // compute the shortest possible names of all files
  // without losing the uniqueness of the file names.
  g_s.begin("Generating disk names...\n");
  generateDiskNames();
  g_s.end();
 
  g_s.begin("Adding source references...\n");
  addSourceReferences();
  g_s.end();
 
  g_s.begin("Adding xrefitems...\n");
  addListReferences();
  generateXRefPages();
  g_s.end();
 
  g_s.begin("Adding requirements...\n");
  addRequirementReferences();
  RequirementManager::instance().generatePage();
  g_s.end();
 
  g_s.begin("Sorting member lists...\n");
  sortMemberLists();
  g_s.end();
 
  g_s.begin("Setting anonymous enum type...\n");
  setAnonymousEnumType();
  g_s.end();
 
  g_s.begin("Computing dependencies between directories...\n");
  computeDirDependencies();
  g_s.end();
 
  g_s.begin("Generating citations page...\n");
  CitationManager::instance().generatePage();
  g_s.end();
 
  g_s.begin("Counting members...\n");
  countMembers();
  g_s.end();
 
  g_s.begin("Counting data structures...\n");
  Index::instance().countDataStructures();
  g_s.end();
 
  g_s.begin("Resolving user defined references...\n");
  resolveUserReferences();
  g_s.end();
 
  g_s.begin("Finding anchors and sections in the documentation...\n");
  findSectionsInDocumentation();
  g_s.end();
 
  g_s.begin("Transferring function references...\n");
  transferFunctionReferences();
  g_s.end();
 
  g_s.begin("Combining using relations...\n");
  combineUsingRelations();
  g_s.end();
 
  initSearchIndexer();
  g_s.begin("Adding members to index pages...\n");
  addMembersToIndex();
  addToIndices();
  g_s.end();
 
  g_s.begin("Correcting members for VHDL...\n");
  vhdlCorrectMemberProperties();
  g_s.end();
 
  g_s.begin("Computing tooltip texts...\n");
  computeTooltipTexts();
  g_s.end();
 
  if (Config_getBool(SORT_GROUP_NAMES))
  {
    std::stable_sort(Doxygen::groupLinkedMap->begin(),
              Doxygen::groupLinkedMap->end(),
              [](const auto &g1,const auto &g2)
              { return g1->groupTitle() < g2->groupTitle(); });
 
    for (const auto &gd : *Doxygen::groupLinkedMap)
    {
      gd->sortSubGroups();
    }
  }
 
  printNavTree(root.get(),0);
  printSectionsTree();
}

References Dir::absPath(), addEnumValuesToEnums(), addListReferences(), addMembersToIndex(), addMembersToMemberGroup(), addRequirementReferences(), addSourceReferences(), addSTLSupport(), addTerminalCharIfMissing(), addToIndices(), AUTO_TRACE, AUTO_TRACE_ADD, begin(), buildClassDocList(), buildClassList(), buildCompleteMemberLists(), buildConceptDocList(), buildConceptList(), buildDefineList(), buildDictionaryList(), buildDirectories(), buildExampleList(), buildFileList(), buildFunctionList(), buildGroupList(), buildInterfaceAndServiceList(), buildListOfUsingDecls(), buildNamespaceList(), buildPageList(), buildRequirementsList(), buildSequenceList(), buildTypedefList(), buildVarList(), checkMarkdownMainfile(), checkPageRelations(), FormulaManager::checkRepositories(), Doxygen::clangAssistedParsing, Doxygen::classLinkedMap, cleanUpDoxygen(), combineUsingRelations(), computeClassRelations(), computeDirDependencies(), computeMemberReferences(), computeMemberRelations(), computePageRelations(), computeTemplateClassRelations(), computeTooltipTexts(), computeVerifiedDotPath(), VhdlDocGen::computeVhdlComponentRelations(), Doxygen::conceptLinkedMap, Config_getBool, Config_getInt, Config_getList, Config_getString, Config_updateList, Config_updateString, Portable::correctPath(), Index::countDataStructures(), countMembers(), createOutputDirectory(), createTemplateInstanceMembers(), Dir::currentDirPath(), distributeConceptGroups(), distributeMemberGroupDocumentation(), end(), QCString::endsWith(), Dir::exists(), FileInfo::exists(), exitDoxygen(), FALSE, fileToString(), Doxygen::filterDBFileName, findClassEntries(), findDefineDocumentation(), findDirDocumentation(), findDocumentedEnumValues(), findEnumDocumentation(), findEnums(), findFriends(), findGroupScope(), findIncludedUsingDirectives(), findInheritedTemplateInstances(), findMainPage(), findMainPageTagFiles(), findMemberDocumentation(), findModuleDocumentation(), findObjCMethodDefinitions(), findSectionsInDocumentation(), findTagLessClasses(), findUsedTemplateInstances(), findUsingDeclarations(), findUsingDeclImports(), findUsingDirectives(), flushCachedTemplateRelations(), flushUnresolvedRelations(), Doxygen::functionNameLinkedMap, g_classEntries, g_commentFileName, g_s, g_singleComment, g_usingClassMap, g_usingDeclarations, generateDiskNames(), generateHtmlForComment(), CitationManager::generatePage(), RequirementManager::generatePage(), generateXRefPages(), Portable::getenv(), getPrefixIndex(), Doxygen::groupLinkedMap, Doxygen::hiddenClassLinkedMap, Doxygen::indexList, inheritDocumentation(), LayoutDocManager::init(), FormulaManager::initFromRepository(), initSearchIndexer(), CitationManager::instance(), FormulaManager::instance(), Index::instance(), LayoutDocManager::instance(), ModuleManager::instance(), RequirementManager::instance(), QCString::isEmpty(), FileInfo::isFile(), Doxygen::memberNameLinkedMap, mergeCategories(), Dir::mkdir(), msg, Doxygen::namespaceLinkedMap, organizeSubGroups(), LayoutDocManager::parse(), parseFilesMultiThreading(), parseFilesSingleThreading(), Portable::pathListSeparator(), Portable::pid(), printLayout(), printNavTree(), printSectionsTree(), qPrint(), qstricmp_sort(), readInputFile(), readTagFile(), resolveClassNestingRelations(), resolveUserReferences(), searchInputFiles(), setAnonymousEnumType(), Portable::setenv(), Dir::setPath(), sortMemberLists(), stopDoxygen(), QCString::str(), Doxygen::symbolLookupCache, term, transferFunctionDocumentation(), transferFunctionReferences(), transferRelatedFunctionDocumentation(), transferStaticInstanceInitializers(), TRUE, Doxygen::typeLookupCache, vhdlCorrectMemberProperties(), warn_uncond, and warnUndocumentedNamespaces().

Referenced by main().

readConfiguration()

void readConfiguration	(	int	argc,
		char **	argv )

Definition at line 11571 of file doxygen.cpp.

{
  QCString versionString = getFullVersion();
 
  // helper that calls \a func to write to file \a fileName via a TextStream
  auto writeFile = [](const char *fileName,std::function<void(TextStream&)> func) -> bool
  {
    std::ofstream f;
    if (openOutputFile(fileName,f))
    {
      TextStream t(&f);
      func(t);
      return true;
    }
    return false;
  };
 
 
  /**************************************************************************
   *             Handle arguments                                           *
   **************************************************************************/
 
  int optInd=1;
  QCString configName;
  QCString traceName;
  bool genConfig=false;
  bool shortList=false;
  bool traceTiming=false;
  Config::CompareMode diffList=Config::CompareMode::Full;
  bool updateConfig=false;
  bool quiet = false;
  while (optInd<argc && argv[optInd][0]=='-' &&
               (isalpha(argv[optInd][1]) || argv[optInd][1]=='?' ||
                argv[optInd][1]=='-')
        )
  {
    switch(argv[optInd][1])
    {
      case 'g':
        {
          genConfig=TRUE;
        }
        break;
      case 'l':
        {
          QCString layoutName;
          if (optInd+1>=argc)
          {
            layoutName="DoxygenLayout.xml";
          }
          else
          {
            layoutName=argv[optInd+1];
          }
          writeDefaultLayoutFile(layoutName);
          cleanUpDoxygen();
          exit(0);
        }
        break;
      case 'c':
        if (optInd+1>=argc) // no file name given
        {
          msg("option \"-c\" is missing the file name to read\n");
          devUsage();
          cleanUpDoxygen();
          exit(1);
        }
        else
        {
          g_commentFileName=argv[optInd+1];
          optInd++;
        }
        g_singleComment=true;
        quiet=true;
        break;
      case 'd':
        {
          QCString debugLabel=getArg(argc,argv,optInd);
          if (debugLabel.isEmpty())
          {
            devUsage();
            cleanUpDoxygen();
            exit(0);
          }
          int retVal = Debug::setFlagStr(debugLabel);
          if (!retVal)
          {
            msg("option \"-d\" has unknown debug specifier: \"{}\".\n",debugLabel);
            devUsage();
            cleanUpDoxygen();
            exit(1);
          }
        }
        break;
      case 't':
        {
#if ENABLE_TRACING
          if (!strcmp(argv[optInd]+1,"t_time"))
          {
            traceTiming = true;
          }
          else if (!strcmp(argv[optInd]+1,"t"))
          {
            traceTiming = false;
          }
          else
          {
            err("option should be \"-t\" or \"-t_time\", found: \"{}\".\n",argv[optInd]);
            cleanUpDoxygen();
            exit(1);
          }
          if (optInd+1>=argc || argv[optInd+1][0] == '-') // no file name given
          {
            traceName="stdout";
          }
          else
          {
            traceName=argv[optInd+1];
            optInd++;
          }
#else
          err("support for option \"-t\" has not been compiled in (use a debug build or a release build with tracing enabled).\n");
          cleanUpDoxygen();
          exit(1);
#endif
        }
        break;
      case 'x':
        if (!strcmp(argv[optInd]+1,"x_noenv")) diffList=Config::CompareMode::CompressedNoEnv;
        else if (!strcmp(argv[optInd]+1,"x")) diffList=Config::CompareMode::Compressed;
        else
        {
          err("option should be \"-x\" or \"-x_noenv\", found: \"{}\".\n",argv[optInd]);
          cleanUpDoxygen();
          exit(1);
        }
        break;
      case 's':
        shortList=TRUE;
        break;
      case 'u':
        updateConfig=TRUE;
        break;
      case 'e':
        {
          QCString formatName=getArg(argc,argv,optInd);
          if (formatName.isEmpty())
          {
            err("option \"-e\" is missing format specifier rtf.\n");
            cleanUpDoxygen();
            exit(1);
          }
          if (qstricmp(formatName.data(),"rtf")==0)
          {
            if (optInd+1>=argc)
            {
              err("option \"-e rtf\" is missing an extensions file name\n");
              cleanUpDoxygen();
              exit(1);
            }
            writeFile(argv[optInd+1],RTFGenerator::writeExtensionsFile);
            cleanUpDoxygen();
            exit(0);
          }
          err("option \"-e\" has invalid format specifier.\n");
          cleanUpDoxygen();
          exit(1);
        }
        break;
      case 'f':
        {
          QCString listName=getArg(argc,argv,optInd);
          if (listName.isEmpty())
          {
            err("option \"-f\" is missing list specifier.\n");
            cleanUpDoxygen();
            exit(1);
          }
          if (qstricmp(listName.data(),"emoji")==0)
          {
            if (optInd+1>=argc)
            {
              err("option \"-f emoji\" is missing an output file name\n");
              cleanUpDoxygen();
              exit(1);
            }
            writeFile(argv[optInd+1],[](TextStream &t) { EmojiEntityMapper::instance().writeEmojiFile(t); });
            cleanUpDoxygen();
            exit(0);
          }
          err("option \"-f\" has invalid list specifier.\n");
          cleanUpDoxygen();
          exit(1);
        }
        break;
      case 'w':
        {
          QCString formatName=getArg(argc,argv,optInd);
          if (formatName.isEmpty())
          {
            err("option \"-w\" is missing format specifier rtf, html or latex\n");
            cleanUpDoxygen();
            exit(1);
          }
          if (qstricmp(formatName.data(),"rtf")==0)
          {
            if (optInd+1>=argc)
            {
              err("option \"-w rtf\" is missing a style sheet file name\n");
              cleanUpDoxygen();
              exit(1);
            }
            if (!writeFile(argv[optInd+1],RTFGenerator::writeStyleSheetFile))
            {
              err("error opening RTF style sheet file {}!\n",argv[optInd+1]);
              cleanUpDoxygen();
              exit(1);
            }
            cleanUpDoxygen();
            exit(0);
          }
          else if (qstricmp(formatName.data(),"html")==0)
          {
            Config::init();
            if (optInd+4<argc || FileInfo("Doxyfile").exists() || FileInfo("doxyfile").exists())
              // explicit config file mentioned or default found on disk
            {
              QCString df = optInd+4<argc ? argv[optInd+4] : (FileInfo("Doxyfile").exists() ? QCString("Doxyfile") : QCString("doxyfile"));
              if (!Config::parse(df)) // parse the config file
              {
                err("error opening or reading configuration file {}!\n",argv[optInd+4]);
                cleanUpDoxygen();
                exit(1);
              }
            }
            if (optInd+3>=argc)
            {
              err("option \"-w html\" does not have enough arguments\n");
              cleanUpDoxygen();
              exit(1);
            }
            Config::postProcess(TRUE);
            Config::updateObsolete();
            Config::checkAndCorrect(Config_getBool(QUIET), false);
            setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
            writeFile(argv[optInd+1],[&](TextStream &t) { HtmlGenerator::writeHeaderFile(t,argv[optInd+3]); });
            writeFile(argv[optInd+2],HtmlGenerator::writeFooterFile);
            writeFile(argv[optInd+3],HtmlGenerator::writeStyleSheetFile);
            cleanUpDoxygen();
            exit(0);
          }
          else if (qstricmp(formatName.data(),"latex")==0)
          {
            Config::init();
            if (optInd+4<argc || FileInfo("Doxyfile").exists() || FileInfo("doxyfile").exists())
            {
              QCString df = optInd+4<argc ? argv[optInd+4] : (FileInfo("Doxyfile").exists() ? QCString("Doxyfile") : QCString("doxyfile"));
              if (!Config::parse(df))
              {
                err("error opening or reading configuration file {}!\n",argv[optInd+4]);
                cleanUpDoxygen();
                exit(1);
              }
            }
            if (optInd+3>=argc)
            {
              err("option \"-w latex\" does not have enough arguments\n");
              cleanUpDoxygen();
              exit(1);
            }
            Config::postProcess(TRUE);
            Config::updateObsolete();
            Config::checkAndCorrect(Config_getBool(QUIET), false);
            setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
            writeFile(argv[optInd+1],LatexGenerator::writeHeaderFile);
            writeFile(argv[optInd+2],LatexGenerator::writeFooterFile);
            writeFile(argv[optInd+3],LatexGenerator::writeStyleSheetFile);
            cleanUpDoxygen();
            exit(0);
          }
          else
          {
            err("Illegal format specifier \"{}\": should be one of rtf, html or latex\n",formatName);
            cleanUpDoxygen();
            exit(1);
          }
        }
        break;
      case 'm':
        g_dumpSymbolMap = TRUE;
        break;
      case 'v':
        version(false);
        cleanUpDoxygen();
        exit(0);
        break;
      case 'V':
        version(true);
        cleanUpDoxygen();
        exit(0);
        break;
      case '-':
        if (qstrcmp(&argv[optInd][2],"help")==0)
        {
          usage(argv[0],versionString);
          exit(0);
        }
        else if (qstrcmp(&argv[optInd][2],"version")==0)
        {
          version(false);
          cleanUpDoxygen();
          exit(0);
        }
        else if ((qstrcmp(&argv[optInd][2],"Version")==0) ||
                 (qstrcmp(&argv[optInd][2],"VERSION")==0))
        {
          version(true);
          cleanUpDoxygen();
          exit(0);
        }
        else
        {
          err("Unknown option \"-{}\"\n",&argv[optInd][1]);
          usage(argv[0],versionString);
          exit(1);
        }
        break;
      case 'b':
        setvbuf(stdout,nullptr,_IONBF,0);
        break;
      case 'q':
        quiet = true;
        break;
      case 'h':
      case '?':
        usage(argv[0],versionString);
        exit(0);
        break;
      default:
        err("Unknown option \"-{:c}\"\n",argv[optInd][1]);
        usage(argv[0],versionString);
        exit(1);
    }
    optInd++;
  }
 
  /**************************************************************************
   *            Parse or generate the config file                           *
   **************************************************************************/
 
  initTracing(traceName.data(),traceTiming);
  TRACE("Doxygen version used: {}",getFullVersion());
  Config::init();
 
  FileInfo configFileInfo1("Doxyfile"),configFileInfo2("doxyfile");
  if (optInd>=argc)
  {
    if (configFileInfo1.exists())
    {
      configName="Doxyfile";
    }
    else if (configFileInfo2.exists())
    {
      configName="doxyfile";
    }
    else if (genConfig)
    {
      configName="Doxyfile";
    }
    else
    {
      err("Doxyfile not found and no input file specified!\n");
      usage(argv[0],versionString);
      exit(1);
    }
  }
  else
  {
    FileInfo fi(argv[optInd]);
    if (fi.exists() || qstrcmp(argv[optInd],"-")==0 || genConfig)
    {
      configName=argv[optInd];
    }
    else
    {
      err("configuration file {} not found!\n",argv[optInd]);
      usage(argv[0],versionString);
      exit(1);
    }
  }
 
  if (genConfig)
  {
    generateConfigFile(configName,shortList);
    cleanUpDoxygen();
    exit(0);
  }
 
  if (!Config::parse(configName,updateConfig,diffList))
  {
    err("could not open or read configuration file {}!\n",configName);
    cleanUpDoxygen();
    exit(1);
  }
 
  if (diffList!=Config::CompareMode::Full)
  {
    Config::updateObsolete();
    compareDoxyfile(diffList);
    cleanUpDoxygen();
    exit(0);
  }
 
  if (updateConfig)
  {
    Config::updateObsolete();
    generateConfigFile(configName,shortList,TRUE);
    cleanUpDoxygen();
    exit(0);
  }
 
  /* Perlmod wants to know the path to the config file.*/
  FileInfo configFileInfo(configName.str());
  setPerlModDoxyfile(configFileInfo.absFilePath());
 
  /* handle -q option */
  if (quiet) Config_updateBool(QUIET,TRUE);
}

References FileInfo::absFilePath(), Config::checkAndCorrect(), cleanUpDoxygen(), compareDoxyfile(), Config::Compressed, Config::CompressedNoEnv, Config_getBool, Config_getEnum, Config_updateBool, QCString::data(), devUsage(), err, FileInfo::exists(), Config::Full, g_commentFileName, g_dumpSymbolMap, g_singleComment, generateConfigFile(), getArg(), Config::init(), initTracing(), EmojiEntityMapper::instance(), QCString::isEmpty(), msg, openOutputFile(), Config::parse(), Config::postProcess(), qstrcmp(), qstricmp(), Debug::setFlagStr(), setPerlModDoxyfile(), setTranslator(), QCString::str(), TRACE, TRUE, Config::updateObsolete(), usage(), version(), writeDefaultLayoutFile(), EmojiEntityMapper::writeEmojiFile(), RTFGenerator::writeExtensionsFile(), HtmlGenerator::writeFooterFile(), LatexGenerator::writeFooterFile(), HtmlGenerator::writeHeaderFile(), LatexGenerator::writeHeaderFile(), HtmlGenerator::writeStyleSheetFile(), LatexGenerator::writeStyleSheetFile(), and RTFGenerator::writeStyleSheetFile().

Referenced by main().

readFileOrDirectory()

void readFileOrDirectory	(	const QCString &	s,
		FileNameLinkedMap *	fnDict,
		StringUnorderedSet *	exclSet,
		const StringVector *	patList,
		const StringVector *	exclPatList,
		StringVector *	resultList,
		StringUnorderedSet *	resultSet,
		bool	recursive,
		bool	errorIfNotExist = TRUE,
		StringUnorderedSet *	killSet = nullptr,
		StringUnorderedSet *	paths = nullptr )

Definition at line 11217 of file doxygen.cpp.

{
  //printf("killSet count=%d\n",killSet ? (int)killSet->size() : -1);
  // strip trailing slashes
  if (s.isEmpty()) return;
 
  g_pathsVisited.clear();
 
  FileInfo fi(s.str());
  //printf("readFileOrDirectory(%s)\n",s);
  {
    if (exclSet==nullptr || exclSet->find(fi.absFilePath())==exclSet->end())
    {
      if (Config_getBool(EXCLUDE_SYMLINKS) && fi.isSymLink())
      {
      }
      else if (!fi.exists() || !fi.isReadable())
      {
        if (errorIfNotExist)
        {
          warn_uncond("source '{}' is not a readable file or directory... skipping.\n",s);
        }
      }
      else if (fi.isFile())
      {
        std::string dirPath = fi.dirPath(true);
        std::string filePath = fi.absFilePath();
        if (paths && !dirPath.empty())
        {
          paths->insert(dirPath);
        }
        //printf("killSet.find(%s)=%d\n",qPrint(fi.absFilePath()),killSet.find(fi.absFilePath())!=killSet.end());
        if (killSet==nullptr || killSet->find(filePath)==killSet->end())
        {
          std::string name=fi.fileName();
          if (fnMap)
          {
            auto fd = createFileDef(dirPath+"/",name);
            if (!name.empty())
            {
              FileName *fn = fnMap->add(name,filePath);
              fn->push_back(std::move(fd));
            }
          }
          if (resultList || resultSet)
          {
            if (resultList) resultList->push_back(filePath);
            if (resultSet) resultSet->insert(filePath);
          }
 
          if (killSet) killSet->insert(fi.absFilePath());
        }
      }
      else if (fi.isDir()) // readable dir
      {
        readDir(&fi,fnMap,exclSet,patList,
            exclPatList,resultList,resultSet,errorIfNotExist,
            recursive,killSet,paths);
      }
    }
  }
}

References FileInfo::absFilePath(), LinkedMap< T, Hash, KeyEqual, Map >::add(), Config_getBool, createFileDef(), FileInfo::dirPath(), FileInfo::exists(), FileInfo::fileName(), g_pathsVisited(), FileInfo::isDir(), QCString::isEmpty(), FileInfo::isFile(), FileInfo::isReadable(), FileInfo::isSymLink(), readDir(), QCString::str(), and warn_uncond.

Referenced by searchInputFiles().