Doxygen
Loading...
Searching...
No Matches
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 83 of file doxygen.h.

◆ InputFileEncodingList

Definition at line 81 of file doxygen.h.

◆ NamespaceAliasInfoMap

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

Definition at line 87 of file doxygen.h.

◆ StaticInitMap

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

Definition at line 85 of file doxygen.h.

Function Documentation

◆ adjustConfiguration()

void adjustConfiguration ( )

adjust globals that depend on configuration settings.

Definition at line 11884 of file doxygen.cpp.

11885{
11886 AUTO_TRACE();
11887 Doxygen::globalNamespaceDef = createNamespaceDef("<globalScope>",1,1,"<globalScope>");
11897
11898 setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
11899
11900 /* Set the global html file extension. */
11901 Doxygen::htmlFileExtension = Config_getString(HTML_FILE_EXTENSION);
11902
11903
11905 Config_getBool(CALLER_GRAPH) ||
11906 Config_getBool(REFERENCES_RELATION) ||
11907 Config_getBool(REFERENCED_BY_RELATION);
11908
11909 /**************************************************************************
11910 * Add custom extension mappings
11911 **************************************************************************/
11912
11913 const StringVector &extMaps = Config_getList(EXTENSION_MAPPING);
11914 for (const auto &mapping : extMaps)
11915 {
11916 QCString mapStr = mapping;
11917 int i=mapStr.find('=');
11918 if (i==-1)
11919 {
11920 continue;
11921 }
11922 else
11923 {
11924 QCString ext = mapStr.left(i).stripWhiteSpace().lower();
11925 QCString language = mapStr.mid(i+1).stripWhiteSpace().lower();
11926 if (ext.isEmpty() || language.isEmpty())
11927 {
11928 continue;
11929 }
11930
11931 if (!updateLanguageMapping(ext,language))
11932 {
11933 err("Failed to map file extension '{}' to unsupported language '{}'.\n"
11934 "Check the EXTENSION_MAPPING setting in the config file.\n",
11935 ext,language);
11936 }
11937 else
11938 {
11939 msg("Adding custom extension mapping: '{}' will be treated as language '{}'\n",
11940 ext,language);
11941 }
11942 }
11943 }
11944 // create input file exncodings
11945
11946 // check INPUT_ENCODING
11947 void *cd = portable_iconv_open("UTF-8",Config_getString(INPUT_ENCODING).data());
11948 if (cd==reinterpret_cast<void *>(-1))
11949 {
11950 term("unsupported character conversion: '{}'->'UTF-8': {}\n"
11951 "Check the 'INPUT_ENCODING' setting in the config file!\n",
11952 Config_getString(INPUT_ENCODING),strerror(errno));
11953 }
11954 else
11955 {
11957 }
11958
11959 // check and split INPUT_FILE_ENCODING
11960 const StringVector &fileEncod = Config_getList(INPUT_FILE_ENCODING);
11961 for (const auto &mapping : fileEncod)
11962 {
11963 QCString mapStr = mapping;
11964 int i=mapStr.find('=');
11965 if (i==-1)
11966 {
11967 continue;
11968 }
11969 else
11970 {
11971 QCString pattern = mapStr.left(i).stripWhiteSpace().lower();
11972 QCString encoding = mapStr.mid(i+1).stripWhiteSpace().lower();
11973 if (pattern.isEmpty() || encoding.isEmpty())
11974 {
11975 continue;
11976 }
11977 cd = portable_iconv_open("UTF-8",encoding.data());
11978 if (cd==reinterpret_cast<void *>(-1))
11979 {
11980 term("unsupported character conversion: '{}'->'UTF-8': {}\n"
11981 "Check the 'INPUT_FILE_ENCODING' setting in the config file!\n",
11982 encoding,strerror(errno));
11983 }
11984 else
11985 {
11987 }
11988
11989 Doxygen::inputFileEncodingList.emplace_back(pattern, encoding);
11990 }
11991 }
11992
11993 // add predefined macro name to a dictionary
11994 const StringVector &expandAsDefinedList =Config_getList(EXPAND_AS_DEFINED);
11995 for (const auto &s : expandAsDefinedList)
11996 {
11998 }
11999
12000 // read aliases and store them in a dictionary
12001 readAliases();
12002
12003 // store number of spaces in a tab into Doxygen::spaces
12004 int tabSize = Config_getInt(TAB_SIZE);
12005 Doxygen::spaces.resize(tabSize);
12006 for (int sp=0; sp<tabSize; sp++) Doxygen::spaces.at(sp)=' ';
12007 Doxygen::spaces.at(tabSize)='\0';
12008}
void readAliases()
Definition aliases.cpp:161
static FileNameLinkedMap * plantUmlFileNameLinkedMap
Definition doxygen.h:110
static bool parseSourcesNeeded
Definition doxygen.h:123
static StringUnorderedSet expandAsDefinedSet
Definition doxygen.h:119
static FileNameLinkedMap * inputNameLinkedMap
Definition doxygen.h:105
static InputFileEncodingList inputFileEncodingList
Definition doxygen.h:140
static FileNameLinkedMap * dotFileNameLinkedMap
Definition doxygen.h:107
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
static FileNameLinkedMap * imageNameLinkedMap
Definition doxygen.h:106
static FileNameLinkedMap * mscFileNameLinkedMap
Definition doxygen.h:108
static QCString spaces
Definition doxygen.h:135
static FileNameLinkedMap * diaFileNameLinkedMap
Definition doxygen.h:109
static QCString htmlFileExtension
Definition doxygen.h:122
static std::unique_ptr< NamespaceDef > globalNamespaceDef
Definition doxygen.h:120
static FileNameLinkedMap * includeNameLinkedMap
Definition doxygen.h:102
static FileNameLinkedMap * exampleNameLinkedMap
Definition doxygen.h:103
Ordered dictionary of FileName objects.
Definition filename.h:73
This is an alternative implementation of QCString.
Definition qcstring.h:101
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:241
QCString lower() const
Definition qcstring.h:249
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:260
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:172
QCString left(size_t len) const
Definition qcstring.h:229
#define Config_getInt(name)
Definition config.h:34
#define Config_getList(name)
Definition config.h:38
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
#define Config_getEnum(name)
Definition config.h:35
std::vector< std::string > StringVector
Definition containers.h:33
#define AUTO_TRACE(...)
Definition docnode.cpp:46
void setTranslator(OUTPUT_LANGUAGE_t langName)
Definition language.cpp:73
#define msg(fmt,...)
Definition message.h:94
#define err(fmt,...)
Definition message.h:127
#define term(fmt,...)
Definition message.h:137
std::unique_ptr< NamespaceDef > createNamespaceDef(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const QCString &ref, const QCString &refFile, const QCString &type, bool isPublished)
Factory method to create new NamespaceDef instance.
NamespaceDefMutable * toNamespaceDefMutable(Definition *d)
int portable_iconv_close(void *cd)
void * portable_iconv_open(const char *tocode, const char *fromcode)
bool updateLanguageMapping(const QCString &extension, const QCString &language)
Definition util.cpp:5022

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 11873 of file doxygen.cpp.

11874{
11875 AUTO_TRACE();
11876
11881}
void initWarningFormat()
Definition message.cpp:237
void postProcess(bool clearHeaderAndFooter, CompareMode compareMode=CompareMode::Full)
void checkAndCorrect(bool quiet, const bool check)
void updateObsolete()
#define FALSE
Definition qcstring.h:34

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

Referenced by main().

◆ cleanUpDoxygen()

void cleanUpDoxygen ( )

Definition at line 11399 of file doxygen.cpp.

11400{
11404
11405 delete Doxygen::indexList;
11414 Doxygen::mainPage.reset();
11418 Doxygen::globalScope = nullptr;
11420 delete theTranslator;
11421 delete g_outputList;
11422
11427 delete Doxygen::dirLinkedMap;
11428 delete Doxygen::symbolMap;
11429}
static NamespaceLinkedMap * namespaceLinkedMap
Definition doxygen.h:115
static std::unique_ptr< PageDef > mainPage
Definition doxygen.h:101
static ParserManager * parserManager
Definition doxygen.h:131
static MemberNameLinkedMap * functionNameLinkedMap
Definition doxygen.h:112
static PageLinkedMap * exampleLinkedMap
Definition doxygen.h:99
static IndexList * indexList
Definition doxygen.h:134
static PageLinkedMap * pageLinkedMap
Definition doxygen.h:100
static DirLinkedMap * dirLinkedMap
Definition doxygen.h:129
static MemberNameLinkedMap * memberNameLinkedMap
Definition doxygen.h:111
static SymbolMap< Definition > * symbolMap
Definition doxygen.h:125
static GroupLinkedMap * groupLinkedMap
Definition doxygen.h:114
static FormulaManager & instance()
Definition formula.cpp:54
void clear()
Definition linkedmap.h:212
static ModuleManager & instance()
static SectionManager & instance()
returns a reference to the singleton
Definition section.h:178
static OutputList * g_outputList
Definition doxygen.cpp:188
Translator * theTranslator
Definition language.cpp:71

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 13049 of file doxygen.cpp.

13050{
13051 AUTO_TRACE();
13052 /**************************************************************************
13053 * Initialize output generators *
13054 **************************************************************************/
13055
13056 /// add extra languages for which we can only produce syntax highlighted code
13058
13059 //// dump all symbols
13060 if (g_dumpSymbolMap)
13061 {
13062 dumpSymbolMap();
13063 exit(0);
13064 }
13065
13066 bool generateHtml = Config_getBool(GENERATE_HTML);
13067 bool generateLatex = Config_getBool(GENERATE_LATEX);
13068 bool generateMan = Config_getBool(GENERATE_MAN);
13069 bool generateRtf = Config_getBool(GENERATE_RTF);
13070 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
13071
13072
13074 if (generateHtml)
13075 {
13079 }
13080 if (generateLatex)
13081 {
13084 }
13085 if (generateDocbook)
13086 {
13089 }
13090 if (generateMan)
13091 {
13092 g_outputList->add<ManGenerator>();
13094 }
13095 if (generateRtf)
13096 {
13097 g_outputList->add<RTFGenerator>();
13099 }
13100 if (Config_getBool(USE_HTAGS))
13101 {
13103 QCString htmldir = Config_getString(HTML_OUTPUT);
13104 if (!Htags::execute(htmldir))
13105 err("USE_HTAGS is YES but htags(1) failed. \n");
13106 else if (!Htags::loadFilemap(htmldir))
13107 err("htags(1) ended normally but failed to load the filemap. \n");
13108 }
13109
13110 /**************************************************************************
13111 * Generate documentation *
13112 **************************************************************************/
13113
13114 g_s.begin("Generating style sheet...\n");
13115 //printf("writing style info\n");
13116 g_outputList->writeStyleInfo(0); // write first part
13117 g_s.end();
13118
13119 bool searchEngine = Config_getBool(SEARCHENGINE);
13120 bool serverBasedSearch = Config_getBool(SERVER_BASED_SEARCH);
13121
13122 g_s.begin("Generating search indices...\n");
13123 if (searchEngine && !serverBasedSearch && generateHtml)
13124 {
13126 }
13127
13128 // generate search indices (need to do this before writing other HTML
13129 // pages as these contain a drop down menu with options depending on
13130 // what categories we find in this function.
13131 if (generateHtml && searchEngine)
13132 {
13133 QCString searchDirName = Config_getString(HTML_OUTPUT)+"/search";
13134 Dir searchDir(searchDirName.str());
13135 if (!searchDir.exists() && !searchDir.mkdir(searchDirName.str()))
13136 {
13137 term("Could not create search results directory '{}' $PWD='{}'\n",
13138 searchDirName,Dir::currentDirPath());
13139 }
13140 HtmlGenerator::writeSearchData(searchDirName);
13141 if (!serverBasedSearch) // client side search index
13142 {
13144 }
13145 }
13146 g_s.end();
13147
13148 // copy static stuff
13149 if (generateHtml)
13150 {
13152 copyLogo(Config_getString(HTML_OUTPUT));
13153 copyIcon(Config_getString(HTML_OUTPUT));
13154 copyExtraFiles(Config_getList(HTML_EXTRA_FILES),"HTML_EXTRA_FILES",Config_getString(HTML_OUTPUT));
13155 }
13156 if (generateLatex)
13157 {
13159 copyLogo(Config_getString(LATEX_OUTPUT));
13160 copyIcon(Config_getString(LATEX_OUTPUT));
13161 copyExtraFiles(Config_getList(LATEX_EXTRA_FILES),"LATEX_EXTRA_FILES",Config_getString(LATEX_OUTPUT));
13162 }
13163 if (generateDocbook)
13164 {
13165 copyLogo(Config_getString(DOCBOOK_OUTPUT));
13166 copyIcon(Config_getString(DOCBOOK_OUTPUT));
13167 }
13168 if (generateRtf)
13169 {
13170 copyLogo(Config_getString(RTF_OUTPUT));
13171 copyIcon(Config_getString(RTF_OUTPUT));
13172 copyExtraFiles(Config_getList(RTF_EXTRA_FILES),"RTF_EXTRA_FILES",Config_getString(RTF_OUTPUT));
13173 }
13174
13176 if (fm.hasFormulas() && generateHtml
13177 && !Config_getBool(USE_MATHJAX))
13178 {
13179 g_s.begin("Generating images for formulas in HTML...\n");
13180 fm.generateImages(Config_getString(HTML_OUTPUT), Config_getEnum(HTML_FORMULA_FORMAT)==HTML_FORMULA_FORMAT_t::svg ?
13182 g_s.end();
13183 }
13184 if (fm.hasFormulas() && generateRtf)
13185 {
13186 g_s.begin("Generating images for formulas in RTF...\n");
13188 g_s.end();
13189 }
13190
13191 if (fm.hasFormulas() && generateDocbook)
13192 {
13193 g_s.begin("Generating images for formulas in Docbook...\n");
13195 g_s.end();
13196 }
13197
13198 g_s.begin("Generating example documentation...\n");
13200 g_s.end();
13201
13202 g_s.begin("Generating file sources...\n");
13204 g_s.end();
13205
13206 g_s.begin("Generating file documentation...\n");
13208 g_s.end();
13209
13210 g_s.begin("Generating page documentation...\n");
13212 g_s.end();
13213
13214 g_s.begin("Generating group documentation...\n");
13216 g_s.end();
13217
13218 g_s.begin("Generating class documentation...\n");
13220 g_s.end();
13221
13222 g_s.begin("Generating concept documentation...\n");
13224 g_s.end();
13225
13226 g_s.begin("Generating module documentation...\n");
13228 g_s.end();
13229
13230 g_s.begin("Generating namespace documentation...\n");
13232 g_s.end();
13233
13234 if (Config_getBool(GENERATE_LEGEND))
13235 {
13236 g_s.begin("Generating graph info page...\n");
13238 g_s.end();
13239 }
13240
13241 g_s.begin("Generating directory documentation...\n");
13243 g_s.end();
13244
13245 if (g_outputList->size()>0)
13246 {
13248 }
13249
13250 g_s.begin("finalizing index lists...\n");
13251 Doxygen::indexList->finalize();
13252 g_s.end();
13253
13254 g_s.begin("writing tag file...\n");
13255 writeTagFile();
13256 g_s.end();
13257
13258 if (Config_getBool(GENERATE_XML))
13259 {
13260 g_s.begin("Generating XML output...\n");
13262 generateXML();
13264 g_s.end();
13265 }
13266 if (Config_getBool(GENERATE_SQLITE3))
13267 {
13268 g_s.begin("Generating SQLITE3 output...\n");
13270 g_s.end();
13271 }
13272
13273 if (Config_getBool(GENERATE_AUTOGEN_DEF))
13274 {
13275 g_s.begin("Generating AutoGen DEF output...\n");
13276 generateDEF();
13277 g_s.end();
13278 }
13279 if (Config_getBool(GENERATE_PERLMOD))
13280 {
13281 g_s.begin("Generating Perl module output...\n");
13283 g_s.end();
13284 }
13285 if (generateHtml && searchEngine && serverBasedSearch)
13286 {
13287 g_s.begin("Generating search index\n");
13288 if (Doxygen::searchIndex.kind()==SearchIndexIntf::Internal) // write own search index
13289 {
13291 Doxygen::searchIndex.write(Config_getString(HTML_OUTPUT)+"/search/search.idx");
13292 }
13293 else // write data for external search index
13294 {
13296 QCString searchDataFile = Config_getString(SEARCHDATA_FILE);
13297 if (searchDataFile.isEmpty())
13298 {
13299 searchDataFile="searchdata.xml";
13300 }
13301 if (!Portable::isAbsolutePath(searchDataFile.data()))
13302 {
13303 searchDataFile.prepend(Config_getString(OUTPUT_DIRECTORY)+"/");
13304 }
13305 Doxygen::searchIndex.write(searchDataFile);
13306 }
13307 g_s.end();
13308 }
13309
13310 if (generateRtf)
13311 {
13312 g_s.begin("Combining RTF output...\n");
13313 if (!RTFGenerator::preProcessFileInplace(Config_getString(RTF_OUTPUT),"refman.rtf"))
13314 {
13315 err("An error occurred during post-processing the RTF files!\n");
13316 }
13317 g_s.end();
13318 }
13319
13320 g_s.begin("Running plantuml with JAVA...\n");
13322 g_s.end();
13323
13324 if (Config_getBool(HAVE_DOT))
13325 {
13326 g_s.begin("Running dot...\n");
13328 g_s.end();
13329 }
13330
13331 if (generateHtml &&
13332 Config_getBool(GENERATE_HTMLHELP) &&
13333 !Config_getString(HHC_LOCATION).isEmpty())
13334 {
13335 g_s.begin("Running html help compiler...\n");
13337 g_s.end();
13338 }
13339
13340 if ( generateHtml &&
13341 Config_getBool(GENERATE_QHP) &&
13342 !Config_getString(QHG_LOCATION).isEmpty())
13343 {
13344 g_s.begin("Running qhelpgenerator...\n");
13346 g_s.end();
13347 }
13348
13349 g_outputList->cleanup();
13350
13351 msg("type lookup cache used {}/{} hits={} misses={}\n",
13353 Doxygen::typeLookupCache->capacity(),
13355 Doxygen::typeLookupCache->misses());
13356 msg("symbol lookup cache used {}/{} hits={} misses={}\n",
13358 Doxygen::symbolLookupCache->capacity(),
13360 Doxygen::symbolLookupCache->misses());
13361 int typeCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::typeLookupCache->misses()*2/3)); // part of the cache is flushed, hence the 2/3 correction factor
13362 int symbolCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::symbolLookupCache->misses()));
13363 int cacheParam = std::max(typeCacheParam,symbolCacheParam);
13364 if (cacheParam>Config_getInt(LOOKUP_CACHE_SIZE))
13365 {
13366 msg("Note: based on cache misses the ideal setting for LOOKUP_CACHE_SIZE is {} at the cost of higher memory usage.\n",cacheParam);
13367 }
13368
13370 {
13371
13372 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
13373 if (numThreads<1) numThreads=1;
13374 msg("Total elapsed time: {:.6f} seconds\n(of which an average of {:.6f} seconds per thread waiting for external tools to finish)\n",
13375 (static_cast<double>(Debug::elapsedTime())),
13376 Portable::getSysElapsedTime()/static_cast<double>(numThreads)
13377 );
13378 g_s.print();
13379
13381 msg("finished...\n");
13383 }
13384 else
13385 {
13386 msg("finished...\n");
13387 }
13388
13389
13390 /**************************************************************************
13391 * Start cleaning up *
13392 **************************************************************************/
13393
13395
13397 Dir thisDir;
13398 thisDir.remove(Doxygen::filterDBFileName.str());
13400 exitTracing();
13402 delete Doxygen::clangUsrMap;
13404
13405 //dumpDocNodeSizes();
13406}
@ Time
Definition debug.h:35
static void clearFlag(const DebugMask mask)
Definition debug.cpp:122
static bool isFlagSet(const DebugMask mask)
Definition debug.cpp:132
static double elapsedTime()
Definition debug.cpp:200
static void setFlag(const DebugMask mask)
Definition debug.cpp:117
Class representing a directory in the file system.
Definition dir.h:75
static std::string currentDirPath()
Definition dir.cpp:342
bool remove(const std::string &path, bool acceptsAbsPath=true) const
Definition dir.cpp:314
static void init()
bool run()
Definition dot.cpp:128
static DotManager * instance()
Definition dot.cpp:78
static Cache< std::string, LookupInfo > * typeLookupCache
Definition doxygen.h:127
static Cache< std::string, LookupInfo > * symbolLookupCache
Definition doxygen.h:128
static QCString filterDBFileName
Definition doxygen.h:133
static bool generatingXmlOutput
Definition doxygen.h:136
static SearchIndexIntf searchIndex
Definition doxygen.h:124
static ClangUsrMap * clangUsrMap
Definition doxygen.h:126
bool hasFormulas() const
Definition formula.cpp:720
void generateImages(const QCString &outputDir, Format format, HighDPI hd=HighDPI::Off)
Definition formula.cpp:636
Generator for HTML output.
Definition htmlgen.h:96
static void init()
Definition htmlgen.cpp:1203
static void writeSearchPage()
Definition htmlgen.cpp:3170
static void writeTabData()
Additional initialization after indices have been created.
Definition htmlgen.cpp:1354
static void writeSearchData(const QCString &dir)
Definition htmlgen.cpp:1363
static void writeExternalSearchPage()
Definition htmlgen.cpp:3269
Generator for LaTeX output.
Definition latexgen.h:94
static void init()
Definition latexgen.cpp:633
Generator for Man page output.
Definition mangen.h:69
static void init()
Definition mangen.cpp:272
void writeDocumentation(OutputList &ol)
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:315
static PlantumlManager & instance()
Definition plantuml.cpp:231
void run()
Run plant UML tool for all images.
Definition plantuml.cpp:389
QCString & prepend(const char *s)
Definition qcstring.h:422
const std::string & str() const
Definition qcstring.h:552
Generator for RTF output.
Definition rtfgen.h:80
static void init()
Definition rtfgen.cpp:461
static bool preProcessFileInplace(const QCString &path, const QCString &name)
This is an API to a VERY brittle RTF preprocessor that combines nested RTF files.
Definition rtfgen.cpp:2461
void generateDEF()
Definition defgen.cpp:482
void generateDirDocs(OutputList &ol)
Definition dirdef.cpp:1193
static void copyLatexStyleSheet()
static void runQHelpGenerator()
class Statistics g_s
static void copyStyleSheet()
static void generateGroupDocs()
static void generateExampleDocs()
Definition doxygen.cpp:9960
static void dumpSymbolMap()
static void generateFileDocs()
Definition doxygen.cpp:8671
static void copyIcon(const QCString &outputOption)
static void generatePageDocs()
Definition doxygen.cpp:9875
static void generateFileSources()
Definition doxygen.cpp:8505
static void copyLogo(const QCString &outputOption)
static void generateClassDocs()
Definition doxygen.cpp:9106
static int computeIdealCacheParam(size_t v)
static void copyExtraFiles(const StringVector &files, const QCString &filesOption, const QCString &outputOption)
static void runHtmlHelpCompiler()
static bool g_dumpSymbolMap
Definition doxygen.cpp:191
static bool g_successfulRun
Definition doxygen.cpp:190
static void generateNamespaceDocs()
static void writeTagFile()
void cleanUpDoxygen()
static void generateConceptDocs()
Definition doxygen.cpp:9132
void writeGraphInfo(OutputList &ol)
Definition index.cpp:4060
void writeIndexHierarchy(OutputList &ol)
Definition index.cpp:5774
void finishWarnExit()
Definition message.cpp:295
void deinit()
bool isAbsolutePath(const QCString &fileName)
Definition portable.cpp:498
double getSysElapsedTime()
Definition portable.cpp:98
void generatePerlMod()
#define TRUE
Definition qcstring.h:37
void finalizeSearchIndexer()
void createJavaScriptSearchIndex()
void writeJavaScriptSearchIndex()
void generateSqlite3()
static bool execute(const QCString &htmldir)
Definition htags.cpp:38
static bool loadFilemap(const QCString &htmldir)
Definition htags.cpp:107
static bool useHtags
Definition htags.h:23
void exitTracing()
Definition trace.cpp:52
void addCodeOnlyMappings()
Definition util.cpp:5121
void generateXML()
Definition xmlgen.cpp:2214

References addCodeOnlyMappings(), AUTO_TRACE, FormulaManager::Bitmap, Doxygen::clangUsrMap, cleanUpDoxygen(), 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 11330 of file doxygen.cpp.

11331{
11332 initResources();
11333 QCString lang = Portable::getenv("LC_ALL");
11334 if (!lang.isEmpty()) Portable::setenv("LANG",lang);
11335 std::setlocale(LC_ALL,"");
11336 std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
11337 std::setlocale(LC_NUMERIC,"C");
11338
11340
11364
11365 // register any additional parsers here...
11366
11368
11369#if USE_LIBCLANG
11371#endif
11380 Doxygen::pageLinkedMap = new PageLinkedMap; // all doc pages
11381 Doxygen::exampleLinkedMap = new PageLinkedMap; // all examples
11382 //Doxygen::tagDestinationDict.setAutoDelete(TRUE);
11384
11385 // initialization of these globals depends on
11386 // configuration switches so we need to postpone these
11387 Doxygen::globalScope = nullptr;
11396
11397}
static void startTimer()
Definition debug.cpp:195
A linked map of directories.
Definition dirdef.h:173
static ConceptLinkedMap * conceptLinkedMap
Definition doxygen.h:98
static ClassLinkedMap * classLinkedMap
Definition doxygen.h:96
static ClassLinkedMap * hiddenClassLinkedMap
Definition doxygen.h:97
A list of index interfaces.
Definition indexlist.h:64
Ordered dictionary of MemberName objects.
Definition membername.h:63
Manages programming language parsers.
Definition parserintf.h:147
std::function< std::unique_ptr< T >() > make_parser_factory()
void initResources()
std::unordered_map< std::string, const Definition * > ClangUsrMap
Definition doxygen.h:83
void setenv(const QCString &variable, const QCString &value)
Definition portable.cpp:287
QCString getenv(const QCString &variable)
Definition portable.cpp:322
void initDefaultExtensionMapping()
Definition util.cpp:5054

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 12374 of file doxygen.cpp.

12375{
12376 AUTO_TRACE();
12377 std::atexit(exitDoxygen);
12378
12379 Portable::correctPath(Config_getList(EXTERNAL_TOOL_PATH));
12380
12381#if USE_LIBCLANG
12382 Doxygen::clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
12383#endif
12384
12385 // we would like to show the versionString earlier, but we first have to handle the configuration file
12386 // to know the value of the QUIET setting.
12387 QCString versionString = getFullVersion();
12388 msg("Doxygen version used: {}\n",versionString);
12389
12391
12392 /**************************************************************************
12393 * Make sure the output directory exists
12394 **************************************************************************/
12395 QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
12396 if (!g_singleComment)
12397 {
12398 if (outputDirectory.isEmpty())
12399 {
12400 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,Dir::currentDirPath());
12401 }
12402 else
12403 {
12404 Dir dir(outputDirectory.str());
12405 if (!dir.exists())
12406 {
12407 dir.setPath(Dir::currentDirPath());
12408 if (!dir.mkdir(outputDirectory.str()))
12409 {
12410 term("tag OUTPUT_DIRECTORY: Output directory '{}' does not "
12411 "exist and cannot be created\n",outputDirectory);
12412 }
12413 else
12414 {
12415 msg("Notice: Output directory '{}' does not exist. "
12416 "I have created it for you.\n", outputDirectory);
12417 }
12418 dir.setPath(outputDirectory.str());
12419 }
12420 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,dir.absPath());
12421 }
12422 }
12423 AUTO_TRACE_ADD("outputDirectory={}",outputDirectory);
12424
12425 /**************************************************************************
12426 * Initialize global lists and dictionaries
12427 **************************************************************************/
12428
12429 // also scale lookup cache with SYMBOL_CACHE_SIZE
12430 int cacheSize = Config_getInt(LOOKUP_CACHE_SIZE);
12431 if (cacheSize<0) cacheSize=0;
12432 if (cacheSize>9) cacheSize=9;
12433 uint32_t lookupSize = 65536 << cacheSize;
12436
12437#ifdef HAS_SIGNALS
12438 signal(SIGINT, stopDoxygen);
12439#endif
12440
12441 uint32_t pid = Portable::pid();
12442 Doxygen::filterDBFileName.sprintf("doxygen_filterdb_%d.tmp",pid);
12443 Doxygen::filterDBFileName.prepend(outputDirectory+"/");
12444
12445 /**************************************************************************
12446 * Check/create output directories *
12447 **************************************************************************/
12448
12449 bool generateHtml = Config_getBool(GENERATE_HTML);
12450 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
12451 bool generateXml = Config_getBool(GENERATE_XML);
12452 bool generateLatex = Config_getBool(GENERATE_LATEX);
12453 bool generateRtf = Config_getBool(GENERATE_RTF);
12454 bool generateMan = Config_getBool(GENERATE_MAN);
12455 bool generateSql = Config_getBool(GENERATE_SQLITE3);
12456 QCString htmlOutput;
12457 QCString docbookOutput;
12458 QCString xmlOutput;
12459 QCString latexOutput;
12460 QCString rtfOutput;
12461 QCString manOutput;
12462 QCString sqlOutput;
12463
12464 if (!g_singleComment)
12465 {
12466 if (generateHtml)
12467 {
12468 htmlOutput = createOutputDirectory(outputDirectory,Config_getString(HTML_OUTPUT),"/html");
12469 Config_updateString(HTML_OUTPUT,htmlOutput);
12470
12471 QCString sitemapUrl = Config_getString(SITEMAP_URL);
12472 bool generateSitemap = !sitemapUrl.isEmpty();
12473 if (generateSitemap && !sitemapUrl.endsWith("/"))
12474 {
12475 Config_updateString(SITEMAP_URL,sitemapUrl+"/");
12476 }
12477
12478 // add HTML indexers that are enabled
12479 bool generateHtmlHelp = Config_getBool(GENERATE_HTMLHELP);
12480 bool generateEclipseHelp = Config_getBool(GENERATE_ECLIPSEHELP);
12481 bool generateQhp = Config_getBool(GENERATE_QHP);
12482 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
12483 bool generateDocSet = Config_getBool(GENERATE_DOCSET);
12484 if (generateEclipseHelp) Doxygen::indexList->addIndex<EclipseHelp>();
12485 if (generateHtmlHelp) Doxygen::indexList->addIndex<HtmlHelp>();
12486 if (generateQhp) Doxygen::indexList->addIndex<Qhp>();
12487 if (generateSitemap) Doxygen::indexList->addIndex<Sitemap>();
12488 if (generateTreeView) Doxygen::indexList->addIndex<FTVHelp>(TRUE);
12489 if (generateDocSet) Doxygen::indexList->addIndex<DocSets>();
12490 Doxygen::indexList->addIndex<Crawlmap>();
12491 Doxygen::indexList->initialize();
12492 }
12493
12494 if (generateDocbook)
12495 {
12496 docbookOutput = createOutputDirectory(outputDirectory,Config_getString(DOCBOOK_OUTPUT),"/docbook");
12497 Config_updateString(DOCBOOK_OUTPUT,docbookOutput);
12498 }
12499
12500 if (generateXml)
12501 {
12502 xmlOutput = createOutputDirectory(outputDirectory,Config_getString(XML_OUTPUT),"/xml");
12503 Config_updateString(XML_OUTPUT,xmlOutput);
12504 }
12505
12506 if (generateLatex)
12507 {
12508 latexOutput = createOutputDirectory(outputDirectory,Config_getString(LATEX_OUTPUT), "/latex");
12509 Config_updateString(LATEX_OUTPUT,latexOutput);
12510 }
12511
12512 if (generateRtf)
12513 {
12514 rtfOutput = createOutputDirectory(outputDirectory,Config_getString(RTF_OUTPUT),"/rtf");
12515 Config_updateString(RTF_OUTPUT,rtfOutput);
12516 }
12517
12518 if (generateMan)
12519 {
12520 manOutput = createOutputDirectory(outputDirectory,Config_getString(MAN_OUTPUT),"/man");
12521 Config_updateString(MAN_OUTPUT,manOutput);
12522 }
12523
12524 if (generateSql)
12525 {
12526 sqlOutput = createOutputDirectory(outputDirectory,Config_getString(SQLITE3_OUTPUT),"/sqlite3");
12527 Config_updateString(SQLITE3_OUTPUT,sqlOutput);
12528 }
12529 }
12530
12531 if (Config_getBool(HAVE_DOT))
12532 {
12533 QCString curFontPath = Config_getString(DOT_FONTPATH);
12534 if (curFontPath.isEmpty())
12535 {
12536 Portable::getenv("DOTFONTPATH");
12537 QCString newFontPath = ".";
12538 if (!curFontPath.isEmpty())
12539 {
12540 newFontPath+=Portable::pathListSeparator();
12541 newFontPath+=curFontPath;
12542 }
12543 Portable::setenv("DOTFONTPATH",qPrint(newFontPath));
12544 }
12545 else
12546 {
12547 Portable::setenv("DOTFONTPATH",qPrint(curFontPath));
12548 }
12549 }
12550
12551 /**************************************************************************
12552 * Handle layout file *
12553 **************************************************************************/
12554
12556 QCString layoutFileName = Config_getString(LAYOUT_FILE);
12557 bool defaultLayoutUsed = FALSE;
12558 if (layoutFileName.isEmpty())
12559 {
12560 layoutFileName = Config_updateString(LAYOUT_FILE,"DoxygenLayout.xml");
12561 defaultLayoutUsed = TRUE;
12562 }
12563 AUTO_TRACE_ADD("defaultLayoutUsed={}, layoutFileName={}",defaultLayoutUsed,layoutFileName);
12564
12565 FileInfo fi(layoutFileName.str());
12566 if (fi.exists())
12567 {
12568 msg("Parsing layout file {}...\n",layoutFileName);
12569 LayoutDocManager::instance().parse(layoutFileName);
12570 }
12571 else if (!defaultLayoutUsed)
12572 {
12573 warn_uncond("failed to open layout file '{}' for reading! Using default settings.\n",layoutFileName);
12574 }
12575 printLayout();
12576
12577 /**************************************************************************
12578 * Read and preprocess input *
12579 **************************************************************************/
12580
12581 // prevent search in the output directories
12582 StringVector exclPatterns = Config_getList(EXCLUDE_PATTERNS);
12583 if (generateHtml) exclPatterns.push_back(htmlOutput.str());
12584 if (generateDocbook) exclPatterns.push_back(docbookOutput.str());
12585 if (generateXml) exclPatterns.push_back(xmlOutput.str());
12586 if (generateLatex) exclPatterns.push_back(latexOutput.str());
12587 if (generateRtf) exclPatterns.push_back(rtfOutput.str());
12588 if (generateMan) exclPatterns.push_back(manOutput.str());
12589 Config_updateList(EXCLUDE_PATTERNS,exclPatterns);
12590
12591 if (!g_singleComment)
12592 {
12594
12596 }
12597
12598 // Notice: the order of the function calls below is very important!
12599
12600 if (generateHtml && !Config_getBool(USE_MATHJAX))
12601 {
12603 }
12604 if (generateRtf)
12605 {
12607 }
12608 if (generateDocbook)
12609 {
12611 }
12612
12614
12615 /**************************************************************************
12616 * Handle Tag Files *
12617 **************************************************************************/
12618
12619 std::shared_ptr<Entry> root = std::make_shared<Entry>();
12620
12621 if (!g_singleComment)
12622 {
12623 msg("Reading and parsing tag files\n");
12624 const StringVector &tagFileList = Config_getList(TAGFILES);
12625 for (const auto &s : tagFileList)
12626 {
12627 readTagFile(root,s.c_str());
12628 }
12629 }
12630
12631 /**************************************************************************
12632 * Parse source files *
12633 **************************************************************************/
12634
12635 addSTLSupport(root);
12636
12637 g_s.begin("Parsing files\n");
12638 if (g_singleComment)
12639 {
12640 //printf("Parsing comment %s\n",qPrint(g_commentFileName));
12641 if (g_commentFileName=="-")
12642 {
12643 std::string text = fileToString(g_commentFileName).str();
12644 addTerminalCharIfMissing(text,'\n');
12645 generateHtmlForComment("stdin.md",text);
12646 }
12647 else if (FileInfo(g_commentFileName.str()).isFile())
12648 {
12649 std::string text;
12651 addTerminalCharIfMissing(text,'\n');
12653 }
12654 else
12655 {
12656 }
12658 exit(0);
12659 }
12660 else
12661 {
12662 if (Config_getInt(NUM_PROC_THREADS)==1)
12663 {
12665 }
12666 else
12667 {
12669 }
12670 }
12671 g_s.end();
12672
12673 /**************************************************************************
12674 * Gather information *
12675 **************************************************************************/
12676
12677 g_s.begin("Building macro definition list...\n");
12679 g_s.end();
12680
12681 g_s.begin("Building group list...\n");
12682 buildGroupList(root.get());
12683 organizeSubGroups(root.get());
12684 g_s.end();
12685
12686 g_s.begin("Building directory list...\n");
12688 findDirDocumentation(root.get());
12689 g_s.end();
12690
12691 g_s.begin("Building namespace list...\n");
12692 buildNamespaceList(root.get());
12693 findUsingDirectives(root.get());
12694 g_s.end();
12695
12696 g_s.begin("Building file list...\n");
12697 buildFileList(root.get());
12698 g_s.end();
12699
12700 g_s.begin("Building class list...\n");
12701 buildClassList(root.get());
12702 g_s.end();
12703
12704 g_s.begin("Building concept list...\n");
12705 buildConceptList(root.get());
12706 g_s.end();
12707
12708 // build list of using declarations here (global list)
12709 buildListOfUsingDecls(root.get());
12710 g_s.end();
12711
12712 g_s.begin("Computing nesting relations for classes...\n");
12714 g_s.end();
12715 // 1.8.2-20121111: no longer add nested classes to the group as well
12716 //distributeClassGroupRelations();
12717
12718 // calling buildClassList may result in cached relations that
12719 // become invalid after resolveClassNestingRelations(), that's why
12720 // we need to clear the cache here
12721 Doxygen::typeLookupCache->clear();
12722 // we don't need the list of using declaration anymore
12723 g_usingDeclarations.clear();
12724
12725 g_s.begin("Associating documentation with classes...\n");
12726 buildClassDocList(root.get());
12727 g_s.end();
12728
12729 g_s.begin("Associating documentation with concepts...\n");
12730 buildConceptDocList(root.get());
12732 g_s.end();
12733
12734 g_s.begin("Associating documentation with modules...\n");
12735 findModuleDocumentation(root.get());
12736 g_s.end();
12737
12738 g_s.begin("Building example list...\n");
12739 buildExampleList(root.get());
12740 g_s.end();
12741
12742 g_s.begin("Searching for enumerations...\n");
12743 findEnums(root.get());
12744 g_s.end();
12745
12746 // Since buildVarList calls isVarWithConstructor
12747 // and this calls getResolvedClass we need to process
12748 // typedefs first so the relations between classes via typedefs
12749 // are properly resolved. See bug 536385 for an example.
12750 g_s.begin("Searching for documented typedefs...\n");
12751 buildTypedefList(root.get());
12752 g_s.end();
12753
12754 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
12755 {
12756 g_s.begin("Searching for documented sequences...\n");
12757 buildSequenceList(root.get());
12758 g_s.end();
12759
12760 g_s.begin("Searching for documented dictionaries...\n");
12761 buildDictionaryList(root.get());
12762 g_s.end();
12763 }
12764
12765 g_s.begin("Searching for members imported via using declarations...\n");
12766 // this should be after buildTypedefList in order to properly import
12767 // used typedefs
12768 findUsingDeclarations(root.get(),TRUE); // do for python packages first
12769 findUsingDeclarations(root.get(),FALSE); // then the rest
12770 g_s.end();
12771
12772 g_s.begin("Searching for included using directives...\n");
12774 g_s.end();
12775
12776 g_s.begin("Searching for documented variables...\n");
12777 buildVarList(root.get());
12778 g_s.end();
12779
12780 g_s.begin("Building interface member list...\n");
12781 buildInterfaceAndServiceList(root.get()); // UNO IDL
12782
12783 g_s.begin("Building member list...\n"); // using class info only !
12784 buildFunctionList(root.get());
12785 g_s.end();
12786
12787 g_s.begin("Searching for friends...\n");
12788 findFriends();
12789 g_s.end();
12790
12791 g_s.begin("Searching for documented defines...\n");
12792 findDefineDocumentation(root.get());
12793 g_s.end();
12794
12795 g_s.begin("Computing class inheritance relations...\n");
12796 findClassEntries(root.get());
12798 g_s.end();
12799
12800 g_s.begin("Computing class usage relations...\n");
12802 g_s.end();
12803
12804 if (Config_getBool(INLINE_SIMPLE_STRUCTS))
12805 {
12806 g_s.begin("Searching for tag less structs...\n");
12808 g_s.end();
12809 }
12810
12811 g_s.begin("Flushing cached template relations that have become invalid...\n");
12813 g_s.end();
12814
12815 g_s.begin("Warn for undocumented namespaces...\n");
12817 g_s.end();
12818
12819 g_s.begin("Computing class relations...\n");
12822 if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
12823 {
12825 }
12827 g_classEntries.clear();
12828 g_s.end();
12829
12830 g_s.begin("Add enum values to enums...\n");
12831 addEnumValuesToEnums(root.get());
12832 findEnumDocumentation(root.get());
12833 g_s.end();
12834
12835 g_s.begin("Searching for member function documentation...\n");
12836 findObjCMethodDefinitions(root.get());
12837 findMemberDocumentation(root.get()); // may introduce new members !
12838 findUsingDeclImports(root.get()); // may introduce new members !
12839 g_usingClassMap.clear();
12843 g_s.end();
12844
12845 // moved to after finding and copying documentation,
12846 // as this introduces new members see bug 722654
12847 g_s.begin("Creating members for template instances...\n");
12849 g_s.end();
12850
12851 g_s.begin("Building page list...\n");
12852 buildPageList(root.get());
12853 g_s.end();
12854
12855 g_s.begin("Search for main page...\n");
12856 findMainPage(root.get());
12857 findMainPageTagFiles(root.get());
12858 g_s.end();
12859
12860 g_s.begin("Computing page relations...\n");
12861 computePageRelations(root.get());
12863 g_s.end();
12864
12865 g_s.begin("Determining the scope of groups...\n");
12866 findGroupScope(root.get());
12867 g_s.end();
12868
12869 g_s.begin("Computing module relations...\n");
12870 auto &mm = ModuleManager::instance();
12871 mm.resolvePartitions();
12872 mm.resolveImports();
12873 mm.collectExportedSymbols();
12874 g_s.end();
12875
12876 auto memberNameComp = [](const MemberNameLinkedMap::Ptr &n1,const MemberNameLinkedMap::Ptr &n2)
12877 {
12878 return qstricmp_sort(n1->memberName().data()+getPrefixIndex(n1->memberName()),
12879 n2->memberName().data()+getPrefixIndex(n2->memberName())
12880 )<0;
12881 };
12882
12883 auto classComp = [](const ClassLinkedMap::Ptr &c1,const ClassLinkedMap::Ptr &c2)
12884 {
12885 if (Config_getBool(SORT_BY_SCOPE_NAME))
12886 {
12887 return qstricmp_sort(c1->name(), c2->name())<0;
12888 }
12889 else
12890 {
12891 int i = qstricmp_sort(c1->className(), c2->className());
12892 return i==0 ? qstricmp_sort(c1->name(), c2->name())<0 : i<0;
12893 }
12894 };
12895
12896 auto namespaceComp = [](const NamespaceLinkedMap::Ptr &n1,const NamespaceLinkedMap::Ptr &n2)
12897 {
12898 return qstricmp_sort(n1->name(),n2->name())<0;
12899 };
12900
12901 auto conceptComp = [](const ConceptLinkedMap::Ptr &c1,const ConceptLinkedMap::Ptr &c2)
12902 {
12903 return qstricmp_sort(c1->name(),c2->name())<0;
12904 };
12905
12906 g_s.begin("Sorting lists...\n");
12907 std::stable_sort(Doxygen::memberNameLinkedMap->begin(),
12909 memberNameComp);
12910 std::stable_sort(Doxygen::functionNameLinkedMap->begin(),
12912 memberNameComp);
12913 std::stable_sort(Doxygen::hiddenClassLinkedMap->begin(),
12915 classComp);
12916 std::stable_sort(Doxygen::classLinkedMap->begin(),
12918 classComp);
12919 std::stable_sort(Doxygen::conceptLinkedMap->begin(),
12921 conceptComp);
12922 std::stable_sort(Doxygen::namespaceLinkedMap->begin(),
12924 namespaceComp);
12925 g_s.end();
12926
12927 g_s.begin("Determining which enums are documented\n");
12929 g_s.end();
12930
12931 g_s.begin("Computing member relations...\n");
12934 g_s.end();
12935
12936 g_s.begin("Building full member lists recursively...\n");
12938 g_s.end();
12939
12940 g_s.begin("Adding members to member groups.\n");
12942 g_s.end();
12943
12944 if (Config_getBool(DISTRIBUTE_GROUP_DOC))
12945 {
12946 g_s.begin("Distributing member group documentation.\n");
12948 g_s.end();
12949 }
12950
12951 g_s.begin("Computing member references...\n");
12953 g_s.end();
12954
12955 if (Config_getBool(INHERIT_DOCS))
12956 {
12957 g_s.begin("Inheriting documentation...\n");
12959 g_s.end();
12960 }
12961
12962
12963 // compute the shortest possible names of all files
12964 // without losing the uniqueness of the file names.
12965 g_s.begin("Generating disk names...\n");
12967 g_s.end();
12968
12969 g_s.begin("Adding source references...\n");
12971 g_s.end();
12972
12973 g_s.begin("Adding xrefitems...\n");
12976 g_s.end();
12977
12978 g_s.begin("Sorting member lists...\n");
12980 g_s.end();
12981
12982 g_s.begin("Setting anonymous enum type...\n");
12984 g_s.end();
12985
12986 g_s.begin("Computing dependencies between directories...\n");
12988 g_s.end();
12989
12990 g_s.begin("Generating citations page...\n");
12992 g_s.end();
12993
12994 g_s.begin("Counting members...\n");
12995 countMembers();
12996 g_s.end();
12997
12998 g_s.begin("Counting data structures...\n");
13000 g_s.end();
13001
13002 g_s.begin("Resolving user defined references...\n");
13004 g_s.end();
13005
13006 g_s.begin("Finding anchors and sections in the documentation...\n");
13008 g_s.end();
13009
13010 g_s.begin("Transferring function references...\n");
13012 g_s.end();
13013
13014 g_s.begin("Combining using relations...\n");
13016 g_s.end();
13017
13019 g_s.begin("Adding members to index pages...\n");
13021 addToIndices();
13022 g_s.end();
13023
13024 g_s.begin("Correcting members for VHDL...\n");
13026 g_s.end();
13027
13028 g_s.begin("Computing tooltip texts...\n");
13030 g_s.end();
13031
13032 if (Config_getBool(SORT_GROUP_NAMES))
13033 {
13034 std::stable_sort(Doxygen::groupLinkedMap->begin(),
13036 [](const auto &g1,const auto &g2)
13037 { return g1->groupTitle() < g2->groupTitle(); });
13038
13039 for (const auto &gd : *Doxygen::groupLinkedMap)
13040 {
13041 gd->sortSubGroups();
13042 }
13043 }
13044
13045 printNavTree(root.get(),0);
13047}
Definition cache.h:32
static CitationManager & instance()
Definition cite.cpp:86
void generatePage()
Generate the citations page.
Definition cite.cpp:332
A class that generates docset files.
Definition docsets.h:36
static bool clangAssistedParsing
Definition doxygen.h:138
Generator for Eclipse help files.
Definition eclipsehelp.h:44
A class that generates a dynamic tree view side panel.
Definition ftvhelp.h:41
Minimal replacement for QFileInfo.
Definition fileinfo.h:23
bool isFile() const
Definition fileinfo.cpp:63
void initFromRepository(const QCString &dir)
Definition formula.cpp:60
void checkRepositories()
Definition formula.cpp:173
A class that generated the HTML Help specific files.
Definition htmlhelp.h:36
static Index & instance()
Definition index.cpp:106
void countDataStructures()
Definition index.cpp:262
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition layout.cpp:1437
void parse(const QCString &fileName, const char *data=nullptr)
Parses a user provided layout.
Definition layout.cpp:1470
std::unique_ptr< MemberName > Ptr
Definition linkedmap.h:38
bool endsWith(const char *s) const
Definition qcstring.h:524
Definition qhp.h:27
static void computeVhdlComponentRelations()
#define Config_updateString(name, value)
Definition config.h:39
#define Config_updateList(name,...)
Definition config.h:43
DirIterator begin(DirIterator it) noexcept
Definition dir.cpp:170
DirIterator end(const DirIterator &) noexcept
Definition dir.cpp:175
void buildDirectories()
Definition dirdef.cpp:1102
void computeDirDependencies()
Definition dirdef.cpp:1176
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:47
static void findInheritedTemplateInstances()
Definition doxygen.cpp:5242
void printNavTree(Entry *root, int indent)
Definition doxygen.cpp:9921
static void buildGroupList(const Entry *root)
Definition doxygen.cpp:425
static void findUsingDeclarations(const Entry *root, bool filterPythonPackages)
Definition doxygen.cpp:2006
static void flushCachedTemplateRelations()
Definition doxygen.cpp:9348
static void computeTemplateClassRelations()
Definition doxygen.cpp:5336
void printSectionsTree()
Definition doxygen.cpp:9944
static void generateXRefPages()
Definition doxygen.cpp:5508
static void findUsingDeclImports(const Entry *root)
Definition doxygen.cpp:2159
static void findDirDocumentation(const Entry *root)
Definition doxygen.cpp:9585
static void warnUndocumentedNamespaces()
Definition doxygen.cpp:5291
static void buildConceptList(const Entry *root)
Definition doxygen.cpp:1277
static void resolveClassNestingRelations()
Definition doxygen.cpp:1332
static void findClassEntries(const Entry *root)
Definition doxygen.cpp:5205
static void vhdlCorrectMemberProperties()
Definition doxygen.cpp:8306
static void stopDoxygen(int)
static void computeMemberReferences()
Definition doxygen.cpp:5405
static void transferRelatedFunctionDocumentation()
Definition doxygen.cpp:4361
static void addMembersToMemberGroup()
Definition doxygen.cpp:9213
static void findMainPageTagFiles(Entry *root)
Definition doxygen.cpp:9745
static void distributeConceptGroups()
Definition doxygen.cpp:1299
static void transferFunctionDocumentation()
Definition doxygen.cpp:4280
static void setAnonymousEnumType()
Definition doxygen.cpp:8953
static void sortMemberLists()
Definition doxygen.cpp:8858
static void createTemplateInstanceMembers()
Definition doxygen.cpp:8434
void transferStaticInstanceInitializers()
Definition doxygen.cpp:4410
static void findObjCMethodDefinitions(const Entry *root)
Definition doxygen.cpp:7450
static void buildTypedefList(const Entry *root)
Definition doxygen.cpp:3353
static void findGroupScope(const Entry *root)
Definition doxygen.cpp:440
static void findDefineDocumentation(Entry *root)
Definition doxygen.cpp:9498
static void findMemberDocumentation(const Entry *root)
Definition doxygen.cpp:7420
static void distributeMemberGroupDocumentation()
Definition doxygen.cpp:9251
static void addEnumValuesToEnums(const Entry *root)
Definition doxygen.cpp:7653
static void resolveUserReferences()
Definition doxygen.cpp:9807
static void buildVarList(const Entry *root)
Definition doxygen.cpp:3489
static void buildSequenceList(const Entry *root)
Definition doxygen.cpp:3452
static void buildNamespaceList(const Entry *root)
Definition doxygen.cpp:1671
static void readTagFile(const std::shared_ptr< Entry > &root, const QCString &tagLine)
static void findIncludedUsingDirectives()
Definition doxygen.cpp:2409
static void countMembers()
Definition doxygen.cpp:8967
static void organizeSubGroups(const Entry *root)
Definition doxygen.cpp:484
void searchInputFiles()
static void findFriends()
Definition doxygen.cpp:4183
static void findEnums(const Entry *root)
Definition doxygen.cpp:7478
static void addListReferences()
Definition doxygen.cpp:5439
static void exitDoxygen() noexcept
static void addMembersToIndex()
Definition doxygen.cpp:8096
static void findMainPage(Entry *root)
Definition doxygen.cpp:9675
static void findUsingDirectives(const Entry *root)
Definition doxygen.cpp:1851
static void addSourceReferences()
Definition doxygen.cpp:8731
static void buildExampleList(Entry *root)
Definition doxygen.cpp:9892
static void inheritDocumentation()
Definition doxygen.cpp:9153
static void flushUnresolvedRelations()
Definition doxygen.cpp:9402
static QCString g_commentFileName
Definition doxygen.cpp:192
static void findDocumentedEnumValues()
Definition doxygen.cpp:8088
static void findTagLessClasses()
Definition doxygen.cpp:1647
static void generateDiskNames()
static void addToIndices()
Definition doxygen.cpp:8138
static void computeClassRelations()
Definition doxygen.cpp:5311
static void buildFunctionList(const Entry *root)
Definition doxygen.cpp:3878
static void checkPageRelations()
Definition doxygen.cpp:9787
static void findModuleDocumentation(const Entry *root)
Definition doxygen.cpp:1267
static void findEnumDocumentation(const Entry *root)
Definition doxygen.cpp:7976
static void computePageRelations(Entry *root)
Definition doxygen.cpp:9757
static QCString createOutputDirectory(const QCString &baseDirName, const QCString &formatDirName, const char *defaultDirName)
static StringSet g_usingDeclarations
Definition doxygen.cpp:189
static void buildDictionaryList(const Entry *root)
Definition doxygen.cpp:3470
static void buildClassDocList(const Entry *root)
Definition doxygen.cpp:1138
static void buildPageList(Entry *root)
Definition doxygen.cpp:9648
static void computeVerifiedDotPath()
static bool g_singleComment
Definition doxygen.cpp:193
static void findSectionsInDocumentation()
Definition doxygen.cpp:9289
static void mergeCategories()
Definition doxygen.cpp:8453
static void buildFileList(const Entry *root)
Definition doxygen.cpp:496
static void buildClassList(const Entry *root)
Definition doxygen.cpp:1128
static void findUsedTemplateInstances()
Definition doxygen.cpp:5275
static void computeTooltipTexts()
Definition doxygen.cpp:8907
static void parseFilesSingleThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void buildCompleteMemberLists()
Definition doxygen.cpp:8475
static void combineUsingRelations()
Definition doxygen.cpp:9188
static void checkMarkdownMainfile()
static std::unordered_map< std::string, std::vector< ClassDefMutable * > > g_usingClassMap
Definition doxygen.cpp:2157
static void buildConceptDocList(const Entry *root)
Definition doxygen.cpp:1287
static void parseFilesMultiThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void transferFunctionReferences()
Definition doxygen.cpp:4313
static void buildDefineList()
Definition doxygen.cpp:8810
static void buildInterfaceAndServiceList(const Entry *root)
Definition doxygen.cpp:3583
static void computeMemberRelations()
Definition doxygen.cpp:8418
static void buildListOfUsingDecls(const Entry *root)
Definition doxygen.cpp:1993
static std::multimap< std::string, const Entry * > g_classEntries
Definition doxygen.cpp:186
void printLayout()
Definition layout.cpp:1822
#define warn_uncond(fmt,...)
Definition message.h:122
void correctPath(const StringVector &list)
Correct a possible wrong PATH variable.
Definition portable.cpp:517
QCString pathListSeparator()
Definition portable.cpp:384
uint32_t pid()
Definition portable.cpp:249
int qstricmp_sort(const char *str1, const char *str2)
Definition qcstring.h:86
const char * qPrint(const char *s)
Definition qcstring.h:687
void initSearchIndexer()
void generateHtmlForComment(const std::string &fn, const std::string &text)
Helper for implemented the -c option of doxygen, which produces HTML output for a given doxygen forma...
void addSTLSupport(std::shared_ptr< Entry > &root)
Add stub entries for the most used classes in the standard template library.
void addTerminalCharIfMissing(std::string &s, char c)
Definition stringutil.h:84
bool readInputFile(const QCString &fileName, std::string &contents, bool filter, bool isSourceCode)
read a file name fileName and optionally filter and transcode it
Definition util.cpp:5466
QCString fileToString(const QCString &name, bool filter, bool isSourceCode)
Definition util.cpp:1432
int getPrefixIndex(const QCString &name)
Definition util.cpp:3167

References Dir::absPath(), addEnumValuesToEnums(), addListReferences(), addMembersToIndex(), addMembersToMemberGroup(), 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(), 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(), 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(), 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 11443 of file doxygen.cpp.

11444{
11445 QCString versionString = getFullVersion();
11446
11447 // helper that calls \a func to write to file \a fileName via a TextStream
11448 auto writeFile = [](const char *fileName,std::function<void(TextStream&)> func) -> bool
11449 {
11450 std::ofstream f;
11451 if (openOutputFile(fileName,f))
11452 {
11453 TextStream t(&f);
11454 func(t);
11455 return true;
11456 }
11457 return false;
11458 };
11459
11460
11461 /**************************************************************************
11462 * Handle arguments *
11463 **************************************************************************/
11464
11465 int optInd=1;
11466 QCString configName;
11467 QCString traceName;
11468 bool genConfig=false;
11469 bool shortList=false;
11470 bool traceTiming=false;
11472 bool updateConfig=false;
11473 bool quiet = false;
11474 while (optInd<argc && argv[optInd][0]=='-' &&
11475 (isalpha(argv[optInd][1]) || argv[optInd][1]=='?' ||
11476 argv[optInd][1]=='-')
11477 )
11478 {
11479 switch(argv[optInd][1])
11480 {
11481 case 'g':
11482 {
11483 genConfig=TRUE;
11484 }
11485 break;
11486 case 'l':
11487 {
11488 QCString layoutName;
11489 if (optInd+1>=argc)
11490 {
11491 layoutName="DoxygenLayout.xml";
11492 }
11493 else
11494 {
11495 layoutName=argv[optInd+1];
11496 }
11497 writeDefaultLayoutFile(layoutName);
11499 exit(0);
11500 }
11501 break;
11502 case 'c':
11503 if (optInd+1>=argc) // no file name given
11504 {
11505 msg("option \"-c\" is missing the file name to read\n");
11506 devUsage();
11508 exit(1);
11509 }
11510 else
11511 {
11512 g_commentFileName=argv[optInd+1];
11513 optInd++;
11514 }
11515 g_singleComment=true;
11516 quiet=true;
11517 break;
11518 case 'd':
11519 {
11520 QCString debugLabel=getArg(argc,argv,optInd);
11521 if (debugLabel.isEmpty())
11522 {
11523 devUsage();
11525 exit(0);
11526 }
11527 int retVal = Debug::setFlagStr(debugLabel);
11528 if (!retVal)
11529 {
11530 msg("option \"-d\" has unknown debug specifier: \"{}\".\n",debugLabel);
11531 devUsage();
11533 exit(1);
11534 }
11535 }
11536 break;
11537 case 't':
11538 {
11539#if ENABLE_TRACING
11540 if (!strcmp(argv[optInd]+1,"t_time"))
11541 {
11542 traceTiming = true;
11543 }
11544 else if (!strcmp(argv[optInd]+1,"t"))
11545 {
11546 traceTiming = false;
11547 }
11548 else
11549 {
11550 err("option should be \"-t\" or \"-t_time\", found: \"{}\".\n",argv[optInd]);
11552 exit(1);
11553 }
11554 if (optInd+1>=argc || argv[optInd+1][0] == '-') // no file name given
11555 {
11556 traceName="stdout";
11557 }
11558 else
11559 {
11560 traceName=argv[optInd+1];
11561 optInd++;
11562 }
11563#else
11564 err("support for option \"-t\" has not been compiled in (use a debug build or a release build with tracing enabled).\n");
11566 exit(1);
11567#endif
11568 }
11569 break;
11570 case 'x':
11571 if (!strcmp(argv[optInd]+1,"x_noenv")) diffList=Config::CompareMode::CompressedNoEnv;
11572 else if (!strcmp(argv[optInd]+1,"x")) diffList=Config::CompareMode::Compressed;
11573 else
11574 {
11575 err("option should be \"-x\" or \"-x_noenv\", found: \"{}\".\n",argv[optInd]);
11577 exit(1);
11578 }
11579 break;
11580 case 's':
11581 shortList=TRUE;
11582 break;
11583 case 'u':
11584 updateConfig=TRUE;
11585 break;
11586 case 'e':
11587 {
11588 QCString formatName=getArg(argc,argv,optInd);
11589 if (formatName.isEmpty())
11590 {
11591 err("option \"-e\" is missing format specifier rtf.\n");
11593 exit(1);
11594 }
11595 if (qstricmp(formatName.data(),"rtf")==0)
11596 {
11597 if (optInd+1>=argc)
11598 {
11599 err("option \"-e rtf\" is missing an extensions file name\n");
11601 exit(1);
11602 }
11603 writeFile(argv[optInd+1],RTFGenerator::writeExtensionsFile);
11605 exit(0);
11606 }
11607 err("option \"-e\" has invalid format specifier.\n");
11609 exit(1);
11610 }
11611 break;
11612 case 'f':
11613 {
11614 QCString listName=getArg(argc,argv,optInd);
11615 if (listName.isEmpty())
11616 {
11617 err("option \"-f\" is missing list specifier.\n");
11619 exit(1);
11620 }
11621 if (qstricmp(listName.data(),"emoji")==0)
11622 {
11623 if (optInd+1>=argc)
11624 {
11625 err("option \"-f emoji\" is missing an output file name\n");
11627 exit(1);
11628 }
11629 writeFile(argv[optInd+1],[](TextStream &t) { EmojiEntityMapper::instance().writeEmojiFile(t); });
11631 exit(0);
11632 }
11633 err("option \"-f\" has invalid list specifier.\n");
11635 exit(1);
11636 }
11637 break;
11638 case 'w':
11639 {
11640 QCString formatName=getArg(argc,argv,optInd);
11641 if (formatName.isEmpty())
11642 {
11643 err("option \"-w\" is missing format specifier rtf, html or latex\n");
11645 exit(1);
11646 }
11647 if (qstricmp(formatName.data(),"rtf")==0)
11648 {
11649 if (optInd+1>=argc)
11650 {
11651 err("option \"-w rtf\" is missing a style sheet file name\n");
11653 exit(1);
11654 }
11655 if (!writeFile(argv[optInd+1],RTFGenerator::writeStyleSheetFile))
11656 {
11657 err("error opening RTF style sheet file {}!\n",argv[optInd+1]);
11659 exit(1);
11660 }
11662 exit(0);
11663 }
11664 else if (qstricmp(formatName.data(),"html")==0)
11665 {
11666 Config::init();
11667 if (optInd+4<argc || FileInfo("Doxyfile").exists() || FileInfo("doxyfile").exists())
11668 // explicit config file mentioned or default found on disk
11669 {
11670 QCString df = optInd+4<argc ? argv[optInd+4] : (FileInfo("Doxyfile").exists() ? QCString("Doxyfile") : QCString("doxyfile"));
11671 if (!Config::parse(df)) // parse the config file
11672 {
11673 err("error opening or reading configuration file {}!\n",argv[optInd+4]);
11675 exit(1);
11676 }
11677 }
11678 if (optInd+3>=argc)
11679 {
11680 err("option \"-w html\" does not have enough arguments\n");
11682 exit(1);
11683 }
11687 setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
11688 writeFile(argv[optInd+1],[&](TextStream &t) { HtmlGenerator::writeHeaderFile(t,argv[optInd+3]); });
11689 writeFile(argv[optInd+2],HtmlGenerator::writeFooterFile);
11690 writeFile(argv[optInd+3],HtmlGenerator::writeStyleSheetFile);
11692 exit(0);
11693 }
11694 else if (qstricmp(formatName.data(),"latex")==0)
11695 {
11696 Config::init();
11697 if (optInd+4<argc || FileInfo("Doxyfile").exists() || FileInfo("doxyfile").exists())
11698 {
11699 QCString df = optInd+4<argc ? argv[optInd+4] : (FileInfo("Doxyfile").exists() ? QCString("Doxyfile") : QCString("doxyfile"));
11700 if (!Config::parse(df))
11701 {
11702 err("error opening or reading configuration file {}!\n",argv[optInd+4]);
11704 exit(1);
11705 }
11706 }
11707 if (optInd+3>=argc)
11708 {
11709 err("option \"-w latex\" does not have enough arguments\n");
11711 exit(1);
11712 }
11716 setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
11717 writeFile(argv[optInd+1],LatexGenerator::writeHeaderFile);
11718 writeFile(argv[optInd+2],LatexGenerator::writeFooterFile);
11719 writeFile(argv[optInd+3],LatexGenerator::writeStyleSheetFile);
11721 exit(0);
11722 }
11723 else
11724 {
11725 err("Illegal format specifier \"{}\": should be one of rtf, html or latex\n",formatName);
11727 exit(1);
11728 }
11729 }
11730 break;
11731 case 'm':
11733 break;
11734 case 'v':
11735 version(false);
11737 exit(0);
11738 break;
11739 case 'V':
11740 version(true);
11742 exit(0);
11743 break;
11744 case '-':
11745 if (qstrcmp(&argv[optInd][2],"help")==0)
11746 {
11747 usage(argv[0],versionString);
11748 exit(0);
11749 }
11750 else if (qstrcmp(&argv[optInd][2],"version")==0)
11751 {
11752 version(false);
11754 exit(0);
11755 }
11756 else if ((qstrcmp(&argv[optInd][2],"Version")==0) ||
11757 (qstrcmp(&argv[optInd][2],"VERSION")==0))
11758 {
11759 version(true);
11761 exit(0);
11762 }
11763 else
11764 {
11765 err("Unknown option \"-{}\"\n",&argv[optInd][1]);
11766 usage(argv[0],versionString);
11767 exit(1);
11768 }
11769 break;
11770 case 'b':
11771 setvbuf(stdout,nullptr,_IONBF,0);
11772 break;
11773 case 'q':
11774 quiet = true;
11775 break;
11776 case 'h':
11777 case '?':
11778 usage(argv[0],versionString);
11779 exit(0);
11780 break;
11781 default:
11782 err("Unknown option \"-{:c}\"\n",argv[optInd][1]);
11783 usage(argv[0],versionString);
11784 exit(1);
11785 }
11786 optInd++;
11787 }
11788
11789 /**************************************************************************
11790 * Parse or generate the config file *
11791 **************************************************************************/
11792
11793 initTracing(traceName.data(),traceTiming);
11794 TRACE("Doxygen version used: {}",getFullVersion());
11795 Config::init();
11796
11797 FileInfo configFileInfo1("Doxyfile"),configFileInfo2("doxyfile");
11798 if (optInd>=argc)
11799 {
11800 if (configFileInfo1.exists())
11801 {
11802 configName="Doxyfile";
11803 }
11804 else if (configFileInfo2.exists())
11805 {
11806 configName="doxyfile";
11807 }
11808 else if (genConfig)
11809 {
11810 configName="Doxyfile";
11811 }
11812 else
11813 {
11814 err("Doxyfile not found and no input file specified!\n");
11815 usage(argv[0],versionString);
11816 exit(1);
11817 }
11818 }
11819 else
11820 {
11821 FileInfo fi(argv[optInd]);
11822 if (fi.exists() || qstrcmp(argv[optInd],"-")==0 || genConfig)
11823 {
11824 configName=argv[optInd];
11825 }
11826 else
11827 {
11828 err("configuration file {} not found!\n",argv[optInd]);
11829 usage(argv[0],versionString);
11830 exit(1);
11831 }
11832 }
11833
11834 if (genConfig)
11835 {
11836 generateConfigFile(configName,shortList);
11838 exit(0);
11839 }
11840
11841 if (!Config::parse(configName,updateConfig,diffList))
11842 {
11843 err("could not open or read configuration file {}!\n",configName);
11845 exit(1);
11846 }
11847
11848 if (diffList!=Config::CompareMode::Full)
11849 {
11851 compareDoxyfile(diffList);
11853 exit(0);
11854 }
11855
11856 if (updateConfig)
11857 {
11859 generateConfigFile(configName,shortList,TRUE);
11861 exit(0);
11862 }
11863
11864 /* Perlmod wants to know the path to the config file.*/
11865 FileInfo configFileInfo(configName.str());
11866 setPerlModDoxyfile(configFileInfo.absFilePath());
11867
11868 /* handle -q option */
11869 if (quiet) Config_updateBool(QUIET,TRUE);
11870}
static bool setFlagStr(const QCString &label)
Definition debug.cpp:103
static EmojiEntityMapper & instance()
Returns the one and only instance of the Emoji entity mapper.
Definition emoji.cpp:1978
void writeEmojiFile(TextStream &t)
Writes the list of supported emojis to the given file.
Definition emoji.cpp:1999
bool exists() const
Definition fileinfo.cpp:30
static void writeFooterFile(TextStream &t)
Definition htmlgen.cpp:1537
static void writeStyleSheetFile(TextStream &t)
Definition htmlgen.cpp:1525
static void writeHeaderFile(TextStream &t, const QCString &cssname)
Definition htmlgen.cpp:1531
static void writeFooterFile(TextStream &t)
Definition latexgen.cpp:697
static void writeStyleSheetFile(TextStream &t)
Definition latexgen.cpp:703
static void writeHeaderFile(TextStream &t)
Definition latexgen.cpp:691
static void writeStyleSheetFile(TextStream &t)
Definition rtfgen.cpp:394
static void writeExtensionsFile(TextStream &t)
Definition rtfgen.cpp:409
Text streaming class that buffers data.
Definition textstream.h:36
#define Config_updateBool(name, value)
Definition config.h:40
static void generateConfigFile(const QCString &configFile, bool shortList, bool updateOnly=FALSE)
static void compareDoxyfile(Config::CompareMode diffList)
static void usage(const QCString &name, const QCString &versionString)
static void devUsage()
static void version(const bool extended)
static const char * getArg(int argc, char **argv, int &optInd)
void writeDefaultLayoutFile(const QCString &fileName)
Definition layout.cpp:1734
CompareMode
Definition config.h:54
bool parse(const QCString &fileName, bool update=FALSE, CompareMode compareMode=CompareMode::Full)
void init()
void setPerlModDoxyfile(const QCString &qs)
int qstricmp(const char *s1, const char *s2)
Definition qcstring.cpp:447
int qstrcmp(const char *str1, const char *str2)
Definition qcstring.h:69
void initTracing(const QCString &logFile, bool timing)
Definition trace.cpp:22
#define TRACE(...)
Definition trace.h:77
bool openOutputFile(const QCString &outFile, std::ofstream &f)
Definition util.cpp:6226

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 11093 of file doxygen.cpp.

11105{
11106 //printf("killSet count=%d\n",killSet ? (int)killSet->size() : -1);
11107 // strip trailing slashes
11108 if (s.isEmpty()) return;
11109
11110 g_pathsVisited.clear();
11111
11112 FileInfo fi(s.str());
11113 //printf("readFileOrDirectory(%s)\n",s);
11114 {
11115 if (exclSet==nullptr || exclSet->find(fi.absFilePath())==exclSet->end())
11116 {
11117 if (Config_getBool(EXCLUDE_SYMLINKS) && fi.isSymLink())
11118 {
11119 }
11120 else if (!fi.exists() || !fi.isReadable())
11121 {
11122 if (errorIfNotExist)
11123 {
11124 warn_uncond("source '{}' is not a readable file or directory... skipping.\n",s);
11125 }
11126 }
11127 else if (fi.isFile())
11128 {
11129 std::string dirPath = fi.dirPath(true);
11130 std::string filePath = fi.absFilePath();
11131 if (paths && !dirPath.empty())
11132 {
11133 paths->insert(dirPath);
11134 }
11135 //printf("killSet.find(%s)=%d\n",qPrint(fi.absFilePath()),killSet.find(fi.absFilePath())!=killSet.end());
11136 if (killSet==nullptr || killSet->find(filePath)==killSet->end())
11137 {
11138 std::string name=fi.fileName();
11139 if (fnMap)
11140 {
11141 auto fd = createFileDef(dirPath+"/",name);
11142 if (!name.empty())
11143 {
11144 FileName *fn = fnMap->add(name,filePath);
11145 fn->push_back(std::move(fd));
11146 }
11147 }
11148 if (resultList || resultSet)
11149 {
11150 if (resultList) resultList->push_back(filePath);
11151 if (resultSet) resultSet->insert(filePath);
11152 }
11153
11154 if (killSet) killSet->insert(fi.absFilePath());
11155 }
11156 }
11157 else if (fi.isDir()) // readable dir
11158 {
11159 readDir(&fi,fnMap,exclSet,patList,
11160 exclPatList,resultList,resultSet,errorIfNotExist,
11161 recursive,killSet,paths);
11162 }
11163 }
11164 }
11165}
Class representing all files with a certain base name.
Definition filename.h:30
static StringUnorderedSet g_pathsVisited(1009)
static void readDir(FileInfo *fi, FileNameLinkedMap *fnMap, StringUnorderedSet *exclSet, const StringVector *patList, const StringVector *exclPatList, StringVector *resultList, StringUnorderedSet *resultSet, bool errorIfNotExist, bool recursive, StringUnorderedSet *killSet, StringUnorderedSet *paths)
std::unique_ptr< FileDef > createFileDef(const QCString &p, const QCString &n, const QCString &ref, const QCString &dn)
Definition filedef.cpp:268

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().