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

11899{
11900 AUTO_TRACE();
11901 Doxygen::globalNamespaceDef = createNamespaceDef("<globalScope>",1,1,"<globalScope>");
11911
11912 setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
11913
11914 /* Set the global html file extension. */
11915 Doxygen::htmlFileExtension = Config_getString(HTML_FILE_EXTENSION);
11916
11917
11919 Config_getBool(CALLER_GRAPH) ||
11920 Config_getBool(REFERENCES_RELATION) ||
11921 Config_getBool(REFERENCED_BY_RELATION);
11922
11923 /**************************************************************************
11924 * Add custom extension mappings
11925 **************************************************************************/
11926
11927 const StringVector &extMaps = Config_getList(EXTENSION_MAPPING);
11928 for (const auto &mapping : extMaps)
11929 {
11930 QCString mapStr = mapping;
11931 int i=mapStr.find('=');
11932 if (i==-1)
11933 {
11934 continue;
11935 }
11936 else
11937 {
11938 QCString ext = mapStr.left(i).stripWhiteSpace().lower();
11939 QCString language = mapStr.mid(i+1).stripWhiteSpace().lower();
11940 if (ext.isEmpty() || language.isEmpty())
11941 {
11942 continue;
11943 }
11944
11945 if (!updateLanguageMapping(ext,language))
11946 {
11947 err("Failed to map file extension '{}' to unsupported language '{}'.\n"
11948 "Check the EXTENSION_MAPPING setting in the config file.\n",
11949 ext,language);
11950 }
11951 else
11952 {
11953 msg("Adding custom extension mapping: '{}' will be treated as language '{}'\n",
11954 ext,language);
11955 }
11956 }
11957 }
11958 // create input file exncodings
11959
11960 // check INPUT_ENCODING
11961 void *cd = portable_iconv_open("UTF-8",Config_getString(INPUT_ENCODING).data());
11962 if (cd==reinterpret_cast<void *>(-1))
11963 {
11964 term("unsupported character conversion: '{}'->'UTF-8': {}\n"
11965 "Check the 'INPUT_ENCODING' setting in the config file!\n",
11966 Config_getString(INPUT_ENCODING),strerror(errno));
11967 }
11968 else
11969 {
11971 }
11972
11973 // check and split INPUT_FILE_ENCODING
11974 const StringVector &fileEncod = Config_getList(INPUT_FILE_ENCODING);
11975 for (const auto &mapping : fileEncod)
11976 {
11977 QCString mapStr = mapping;
11978 int i=mapStr.find('=');
11979 if (i==-1)
11980 {
11981 continue;
11982 }
11983 else
11984 {
11985 QCString pattern = mapStr.left(i).stripWhiteSpace().lower();
11986 QCString encoding = mapStr.mid(i+1).stripWhiteSpace().lower();
11987 if (pattern.isEmpty() || encoding.isEmpty())
11988 {
11989 continue;
11990 }
11991 cd = portable_iconv_open("UTF-8",encoding.data());
11992 if (cd==reinterpret_cast<void *>(-1))
11993 {
11994 term("unsupported character conversion: '{}'->'UTF-8': {}\n"
11995 "Check the 'INPUT_FILE_ENCODING' setting in the config file!\n",
11996 encoding,strerror(errno));
11997 }
11998 else
11999 {
12001 }
12002
12003 Doxygen::inputFileEncodingList.emplace_back(pattern, encoding);
12004 }
12005 }
12006
12007 // add predefined macro name to a dictionary
12008 const StringVector &expandAsDefinedList =Config_getList(EXPAND_AS_DEFINED);
12009 for (const auto &s : expandAsDefinedList)
12010 {
12012 }
12013
12014 // read aliases and store them in a dictionary
12015 readAliases();
12016
12017 // store number of spaces in a tab into Doxygen::spaces
12018 int tabSize = Config_getInt(TAB_SIZE);
12019 Doxygen::spaces.resize(tabSize);
12020 for (int sp=0; sp<tabSize; sp++) Doxygen::spaces.at(sp)=' ';
12021 Doxygen::spaces.at(tabSize)='\0';
12022}
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:5029

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

11888{
11889 AUTO_TRACE();
11890
11895}
void initWarningFormat()
Definition message.cpp:236
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 11409 of file doxygen.cpp.

11410{
11414
11415 delete Doxygen::indexList;
11424 Doxygen::mainPage.reset();
11428 Doxygen::globalScope = nullptr;
11430 delete theTranslator;
11431 delete g_outputList;
11432
11437 delete Doxygen::dirLinkedMap;
11438 delete Doxygen::symbolMap;
11439}
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 13063 of file doxygen.cpp.

13064{
13065 AUTO_TRACE();
13066 /**************************************************************************
13067 * Initialize output generators *
13068 **************************************************************************/
13069
13070 /// add extra languages for which we can only produce syntax highlighted code
13072
13073 //// dump all symbols
13074 if (g_dumpSymbolMap)
13075 {
13076 dumpSymbolMap();
13077 exit(0);
13078 }
13079
13080 bool generateHtml = Config_getBool(GENERATE_HTML);
13081 bool generateLatex = Config_getBool(GENERATE_LATEX);
13082 bool generateMan = Config_getBool(GENERATE_MAN);
13083 bool generateRtf = Config_getBool(GENERATE_RTF);
13084 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
13085
13086
13088 if (generateHtml)
13089 {
13093 }
13094 if (generateLatex)
13095 {
13098 }
13099 if (generateDocbook)
13100 {
13103 }
13104 if (generateMan)
13105 {
13106 g_outputList->add<ManGenerator>();
13108 }
13109 if (generateRtf)
13110 {
13111 g_outputList->add<RTFGenerator>();
13113 }
13114 if (Config_getBool(USE_HTAGS))
13115 {
13117 QCString htmldir = Config_getString(HTML_OUTPUT);
13118 if (!Htags::execute(htmldir))
13119 err("USE_HTAGS is YES but htags(1) failed. \n");
13120 else if (!Htags::loadFilemap(htmldir))
13121 err("htags(1) ended normally but failed to load the filemap. \n");
13122 }
13123
13124 /**************************************************************************
13125 * Generate documentation *
13126 **************************************************************************/
13127
13128 g_s.begin("Generating style sheet...\n");
13129 //printf("writing style info\n");
13130 g_outputList->writeStyleInfo(0); // write first part
13131 g_s.end();
13132
13133 bool searchEngine = Config_getBool(SEARCHENGINE);
13134 bool serverBasedSearch = Config_getBool(SERVER_BASED_SEARCH);
13135
13136 g_s.begin("Generating search indices...\n");
13137 if (searchEngine && !serverBasedSearch && generateHtml)
13138 {
13140 }
13141
13142 // generate search indices (need to do this before writing other HTML
13143 // pages as these contain a drop down menu with options depending on
13144 // what categories we find in this function.
13145 if (generateHtml && searchEngine)
13146 {
13147 QCString searchDirName = Config_getString(HTML_OUTPUT)+"/search";
13148 Dir searchDir(searchDirName.str());
13149 if (!searchDir.exists() && !searchDir.mkdir(searchDirName.str()))
13150 {
13151 term("Could not create search results directory '{}' $PWD='{}'\n",
13152 searchDirName,Dir::currentDirPath());
13153 }
13154 HtmlGenerator::writeSearchData(searchDirName);
13155 if (!serverBasedSearch) // client side search index
13156 {
13158 }
13159 }
13160 g_s.end();
13161
13162 // copy static stuff
13163 if (generateHtml)
13164 {
13166 copyLogo(Config_getString(HTML_OUTPUT));
13167 copyIcon(Config_getString(HTML_OUTPUT));
13168 copyExtraFiles(Config_getList(HTML_EXTRA_FILES),"HTML_EXTRA_FILES",Config_getString(HTML_OUTPUT));
13169 }
13170 if (generateLatex)
13171 {
13173 copyLogo(Config_getString(LATEX_OUTPUT));
13174 copyIcon(Config_getString(LATEX_OUTPUT));
13175 copyExtraFiles(Config_getList(LATEX_EXTRA_FILES),"LATEX_EXTRA_FILES",Config_getString(LATEX_OUTPUT));
13176 }
13177 if (generateDocbook)
13178 {
13179 copyLogo(Config_getString(DOCBOOK_OUTPUT));
13180 copyIcon(Config_getString(DOCBOOK_OUTPUT));
13181 }
13182 if (generateRtf)
13183 {
13184 copyLogo(Config_getString(RTF_OUTPUT));
13185 copyIcon(Config_getString(RTF_OUTPUT));
13186 copyExtraFiles(Config_getList(RTF_EXTRA_FILES),"RTF_EXTRA_FILES",Config_getString(RTF_OUTPUT));
13187 }
13188
13190 if (fm.hasFormulas() && generateHtml
13191 && !Config_getBool(USE_MATHJAX))
13192 {
13193 g_s.begin("Generating images for formulas in HTML...\n");
13194 fm.generateImages(Config_getString(HTML_OUTPUT), Config_getEnum(HTML_FORMULA_FORMAT)==HTML_FORMULA_FORMAT_t::svg ?
13196 g_s.end();
13197 }
13198 if (fm.hasFormulas() && generateRtf)
13199 {
13200 g_s.begin("Generating images for formulas in RTF...\n");
13202 g_s.end();
13203 }
13204
13205 if (fm.hasFormulas() && generateDocbook)
13206 {
13207 g_s.begin("Generating images for formulas in Docbook...\n");
13209 g_s.end();
13210 }
13211
13212 g_s.begin("Generating example documentation...\n");
13214 g_s.end();
13215
13216 g_s.begin("Generating file sources...\n");
13218 g_s.end();
13219
13220 g_s.begin("Generating file documentation...\n");
13222 g_s.end();
13223
13224 g_s.begin("Generating page documentation...\n");
13226 g_s.end();
13227
13228 g_s.begin("Generating group documentation...\n");
13230 g_s.end();
13231
13232 g_s.begin("Generating class documentation...\n");
13234 g_s.end();
13235
13236 g_s.begin("Generating concept documentation...\n");
13238 g_s.end();
13239
13240 g_s.begin("Generating module documentation...\n");
13242 g_s.end();
13243
13244 g_s.begin("Generating namespace documentation...\n");
13246 g_s.end();
13247
13248 if (Config_getBool(GENERATE_LEGEND))
13249 {
13250 g_s.begin("Generating graph info page...\n");
13252 g_s.end();
13253 }
13254
13255 g_s.begin("Generating directory documentation...\n");
13257 g_s.end();
13258
13259 if (g_outputList->size()>0)
13260 {
13262 }
13263
13264 g_s.begin("finalizing index lists...\n");
13265 Doxygen::indexList->finalize();
13266 g_s.end();
13267
13268 g_s.begin("writing tag file...\n");
13269 writeTagFile();
13270 g_s.end();
13271
13272 if (Config_getBool(GENERATE_XML))
13273 {
13274 g_s.begin("Generating XML output...\n");
13276 generateXML();
13278 g_s.end();
13279 }
13280 if (Config_getBool(GENERATE_SQLITE3))
13281 {
13282 g_s.begin("Generating SQLITE3 output...\n");
13284 g_s.end();
13285 }
13286
13287 if (Config_getBool(GENERATE_AUTOGEN_DEF))
13288 {
13289 g_s.begin("Generating AutoGen DEF output...\n");
13290 generateDEF();
13291 g_s.end();
13292 }
13293 if (Config_getBool(GENERATE_PERLMOD))
13294 {
13295 g_s.begin("Generating Perl module output...\n");
13297 g_s.end();
13298 }
13299 if (generateHtml && searchEngine && serverBasedSearch)
13300 {
13301 g_s.begin("Generating search index\n");
13302 if (Doxygen::searchIndex.kind()==SearchIndexIntf::Internal) // write own search index
13303 {
13305 Doxygen::searchIndex.write(Config_getString(HTML_OUTPUT)+"/search/search.idx");
13306 }
13307 else // write data for external search index
13308 {
13310 QCString searchDataFile = Config_getString(SEARCHDATA_FILE);
13311 if (searchDataFile.isEmpty())
13312 {
13313 searchDataFile="searchdata.xml";
13314 }
13315 if (!Portable::isAbsolutePath(searchDataFile.data()))
13316 {
13317 searchDataFile.prepend(Config_getString(OUTPUT_DIRECTORY)+"/");
13318 }
13319 Doxygen::searchIndex.write(searchDataFile);
13320 }
13321 g_s.end();
13322 }
13323
13324 if (generateRtf)
13325 {
13326 g_s.begin("Combining RTF output...\n");
13327 if (!RTFGenerator::preProcessFileInplace(Config_getString(RTF_OUTPUT),"refman.rtf"))
13328 {
13329 err("An error occurred during post-processing the RTF files!\n");
13330 }
13331 g_s.end();
13332 }
13333
13334 g_s.begin("Running plantuml with JAVA...\n");
13336 g_s.end();
13337
13338 if (Config_getBool(HAVE_DOT))
13339 {
13340 g_s.begin("Running dot...\n");
13342 g_s.end();
13343 }
13344
13345 if (generateHtml &&
13346 Config_getBool(GENERATE_HTMLHELP) &&
13347 !Config_getString(HHC_LOCATION).isEmpty())
13348 {
13349 g_s.begin("Running html help compiler...\n");
13351 g_s.end();
13352 }
13353
13354 if ( generateHtml &&
13355 Config_getBool(GENERATE_QHP) &&
13356 !Config_getString(QHG_LOCATION).isEmpty())
13357 {
13358 g_s.begin("Running qhelpgenerator...\n");
13360 g_s.end();
13361 }
13362
13363 g_outputList->cleanup();
13364
13365 msg("type lookup cache used {}/{} hits={} misses={}\n",
13367 Doxygen::typeLookupCache->capacity(),
13369 Doxygen::typeLookupCache->misses());
13370 msg("symbol lookup cache used {}/{} hits={} misses={}\n",
13372 Doxygen::symbolLookupCache->capacity(),
13374 Doxygen::symbolLookupCache->misses());
13375 int typeCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::typeLookupCache->misses()*2/3)); // part of the cache is flushed, hence the 2/3 correction factor
13376 int symbolCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::symbolLookupCache->misses()));
13377 int cacheParam = std::max(typeCacheParam,symbolCacheParam);
13378 if (cacheParam>Config_getInt(LOOKUP_CACHE_SIZE))
13379 {
13380 msg("Note: based on cache misses the ideal setting for LOOKUP_CACHE_SIZE is {} at the cost of higher memory usage.\n",cacheParam);
13381 }
13382
13384 {
13385
13386 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
13387 if (numThreads<1) numThreads=1;
13388 msg("Total elapsed time: {:.6f} seconds\n(of which an average of {:.6f} seconds per thread waiting for external tools to finish)\n",
13389 (static_cast<double>(Debug::elapsedTime())),
13390 Portable::getSysElapsedTime()/static_cast<double>(numThreads)
13391 );
13392 g_s.print();
13393
13395 msg("finished...\n");
13397 }
13398 else
13399 {
13400 msg("finished...\n");
13401 }
13402
13403
13404 /**************************************************************************
13405 * Start cleaning up *
13406 **************************************************************************/
13407
13409
13411 Dir thisDir;
13412 thisDir.remove(Doxygen::filterDBFileName.str());
13414 exitTracing();
13416 delete Doxygen::clangUsrMap;
13418
13419 //dumpDocNodeSizes();
13420}
@ 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:9970
static void dumpSymbolMap()
static void generateFileDocs()
Definition doxygen.cpp:8681
static void copyIcon(const QCString &outputOption)
static void generatePageDocs()
Definition doxygen.cpp:9885
static void generateFileSources()
Definition doxygen.cpp:8515
static void copyLogo(const QCString &outputOption)
static void generateClassDocs()
Definition doxygen.cpp:9116
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:9142
void writeGraphInfo(OutputList &ol)
Definition index.cpp:4066
void writeIndexHierarchy(OutputList &ol)
Definition index.cpp:5780
void finishWarnExit()
Definition message.cpp:294
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:5128
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 11340 of file doxygen.cpp.

11341{
11342 initResources();
11343 QCString lang = Portable::getenv("LC_ALL");
11344 if (!lang.isEmpty()) Portable::setenv("LANG",lang);
11345 std::setlocale(LC_ALL,"");
11346 std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
11347 std::setlocale(LC_NUMERIC,"C");
11348
11350
11374
11375 // register any additional parsers here...
11376
11378
11379#if USE_LIBCLANG
11381#endif
11390 Doxygen::pageLinkedMap = new PageLinkedMap; // all doc pages
11391 Doxygen::exampleLinkedMap = new PageLinkedMap; // all examples
11392 //Doxygen::tagDestinationDict.setAutoDelete(TRUE);
11394
11395 // initialization of these globals depends on
11396 // configuration switches so we need to postpone these
11397 Doxygen::globalScope = nullptr;
11406
11407}
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:5061

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

12389{
12390 AUTO_TRACE();
12391 std::atexit(exitDoxygen);
12392
12393 Portable::correctPath(Config_getList(EXTERNAL_TOOL_PATH));
12394
12395#if USE_LIBCLANG
12396 Doxygen::clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
12397#endif
12398
12399 // we would like to show the versionString earlier, but we first have to handle the configuration file
12400 // to know the value of the QUIET setting.
12401 QCString versionString = getFullVersion();
12402 msg("Doxygen version used: {}\n",versionString);
12403
12405
12406 /**************************************************************************
12407 * Make sure the output directory exists
12408 **************************************************************************/
12409 QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
12410 if (!g_singleComment)
12411 {
12412 if (outputDirectory.isEmpty())
12413 {
12414 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,Dir::currentDirPath());
12415 }
12416 else
12417 {
12418 Dir dir(outputDirectory.str());
12419 if (!dir.exists())
12420 {
12421 dir.setPath(Dir::currentDirPath());
12422 if (!dir.mkdir(outputDirectory.str()))
12423 {
12424 term("tag OUTPUT_DIRECTORY: Output directory '{}' does not "
12425 "exist and cannot be created\n",outputDirectory);
12426 }
12427 else
12428 {
12429 msg("Notice: Output directory '{}' does not exist. "
12430 "I have created it for you.\n", outputDirectory);
12431 }
12432 dir.setPath(outputDirectory.str());
12433 }
12434 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,dir.absPath());
12435 }
12436 }
12437 AUTO_TRACE_ADD("outputDirectory={}",outputDirectory);
12438
12439 /**************************************************************************
12440 * Initialize global lists and dictionaries
12441 **************************************************************************/
12442
12443 // also scale lookup cache with SYMBOL_CACHE_SIZE
12444 int cacheSize = Config_getInt(LOOKUP_CACHE_SIZE);
12445 if (cacheSize<0) cacheSize=0;
12446 if (cacheSize>9) cacheSize=9;
12447 uint32_t lookupSize = 65536 << cacheSize;
12450
12451#ifdef HAS_SIGNALS
12452 signal(SIGINT, stopDoxygen);
12453#endif
12454
12455 uint32_t pid = Portable::pid();
12456 Doxygen::filterDBFileName.sprintf("doxygen_filterdb_%d.tmp",pid);
12457 Doxygen::filterDBFileName.prepend(outputDirectory+"/");
12458
12459 /**************************************************************************
12460 * Check/create output directories *
12461 **************************************************************************/
12462
12463 bool generateHtml = Config_getBool(GENERATE_HTML);
12464 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
12465 bool generateXml = Config_getBool(GENERATE_XML);
12466 bool generateLatex = Config_getBool(GENERATE_LATEX);
12467 bool generateRtf = Config_getBool(GENERATE_RTF);
12468 bool generateMan = Config_getBool(GENERATE_MAN);
12469 bool generateSql = Config_getBool(GENERATE_SQLITE3);
12470 QCString htmlOutput;
12471 QCString docbookOutput;
12472 QCString xmlOutput;
12473 QCString latexOutput;
12474 QCString rtfOutput;
12475 QCString manOutput;
12476 QCString sqlOutput;
12477
12478 if (!g_singleComment)
12479 {
12480 if (generateHtml)
12481 {
12482 htmlOutput = createOutputDirectory(outputDirectory,Config_getString(HTML_OUTPUT),"/html");
12483 Config_updateString(HTML_OUTPUT,htmlOutput);
12484
12485 QCString sitemapUrl = Config_getString(SITEMAP_URL);
12486 bool generateSitemap = !sitemapUrl.isEmpty();
12487 if (generateSitemap && !sitemapUrl.endsWith("/"))
12488 {
12489 Config_updateString(SITEMAP_URL,sitemapUrl+"/");
12490 }
12491
12492 // add HTML indexers that are enabled
12493 bool generateHtmlHelp = Config_getBool(GENERATE_HTMLHELP);
12494 bool generateEclipseHelp = Config_getBool(GENERATE_ECLIPSEHELP);
12495 bool generateQhp = Config_getBool(GENERATE_QHP);
12496 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
12497 bool generateDocSet = Config_getBool(GENERATE_DOCSET);
12498 if (generateEclipseHelp) Doxygen::indexList->addIndex<EclipseHelp>();
12499 if (generateHtmlHelp) Doxygen::indexList->addIndex<HtmlHelp>();
12500 if (generateQhp) Doxygen::indexList->addIndex<Qhp>();
12501 if (generateSitemap) Doxygen::indexList->addIndex<Sitemap>();
12502 if (generateTreeView) Doxygen::indexList->addIndex<FTVHelp>(TRUE);
12503 if (generateDocSet) Doxygen::indexList->addIndex<DocSets>();
12504 Doxygen::indexList->addIndex<Crawlmap>();
12505 Doxygen::indexList->initialize();
12506 }
12507
12508 if (generateDocbook)
12509 {
12510 docbookOutput = createOutputDirectory(outputDirectory,Config_getString(DOCBOOK_OUTPUT),"/docbook");
12511 Config_updateString(DOCBOOK_OUTPUT,docbookOutput);
12512 }
12513
12514 if (generateXml)
12515 {
12516 xmlOutput = createOutputDirectory(outputDirectory,Config_getString(XML_OUTPUT),"/xml");
12517 Config_updateString(XML_OUTPUT,xmlOutput);
12518 }
12519
12520 if (generateLatex)
12521 {
12522 latexOutput = createOutputDirectory(outputDirectory,Config_getString(LATEX_OUTPUT), "/latex");
12523 Config_updateString(LATEX_OUTPUT,latexOutput);
12524 }
12525
12526 if (generateRtf)
12527 {
12528 rtfOutput = createOutputDirectory(outputDirectory,Config_getString(RTF_OUTPUT),"/rtf");
12529 Config_updateString(RTF_OUTPUT,rtfOutput);
12530 }
12531
12532 if (generateMan)
12533 {
12534 manOutput = createOutputDirectory(outputDirectory,Config_getString(MAN_OUTPUT),"/man");
12535 Config_updateString(MAN_OUTPUT,manOutput);
12536 }
12537
12538 if (generateSql)
12539 {
12540 sqlOutput = createOutputDirectory(outputDirectory,Config_getString(SQLITE3_OUTPUT),"/sqlite3");
12541 Config_updateString(SQLITE3_OUTPUT,sqlOutput);
12542 }
12543 }
12544
12545 if (Config_getBool(HAVE_DOT))
12546 {
12547 QCString curFontPath = Config_getString(DOT_FONTPATH);
12548 if (curFontPath.isEmpty())
12549 {
12550 Portable::getenv("DOTFONTPATH");
12551 QCString newFontPath = ".";
12552 if (!curFontPath.isEmpty())
12553 {
12554 newFontPath+=Portable::pathListSeparator();
12555 newFontPath+=curFontPath;
12556 }
12557 Portable::setenv("DOTFONTPATH",qPrint(newFontPath));
12558 }
12559 else
12560 {
12561 Portable::setenv("DOTFONTPATH",qPrint(curFontPath));
12562 }
12563 }
12564
12565 /**************************************************************************
12566 * Handle layout file *
12567 **************************************************************************/
12568
12570 QCString layoutFileName = Config_getString(LAYOUT_FILE);
12571 bool defaultLayoutUsed = FALSE;
12572 if (layoutFileName.isEmpty())
12573 {
12574 layoutFileName = Config_updateString(LAYOUT_FILE,"DoxygenLayout.xml");
12575 defaultLayoutUsed = TRUE;
12576 }
12577 AUTO_TRACE_ADD("defaultLayoutUsed={}, layoutFileName={}",defaultLayoutUsed,layoutFileName);
12578
12579 FileInfo fi(layoutFileName.str());
12580 if (fi.exists())
12581 {
12582 msg("Parsing layout file {}...\n",layoutFileName);
12583 LayoutDocManager::instance().parse(layoutFileName);
12584 }
12585 else if (!defaultLayoutUsed)
12586 {
12587 warn_uncond("failed to open layout file '{}' for reading! Using default settings.\n",layoutFileName);
12588 }
12589 printLayout();
12590
12591 /**************************************************************************
12592 * Read and preprocess input *
12593 **************************************************************************/
12594
12595 // prevent search in the output directories
12596 StringVector exclPatterns = Config_getList(EXCLUDE_PATTERNS);
12597 if (generateHtml) exclPatterns.push_back(htmlOutput.str());
12598 if (generateDocbook) exclPatterns.push_back(docbookOutput.str());
12599 if (generateXml) exclPatterns.push_back(xmlOutput.str());
12600 if (generateLatex) exclPatterns.push_back(latexOutput.str());
12601 if (generateRtf) exclPatterns.push_back(rtfOutput.str());
12602 if (generateMan) exclPatterns.push_back(manOutput.str());
12603 Config_updateList(EXCLUDE_PATTERNS,exclPatterns);
12604
12605 if (!g_singleComment)
12606 {
12608
12610 }
12611
12612 // Notice: the order of the function calls below is very important!
12613
12614 if (generateHtml && !Config_getBool(USE_MATHJAX))
12615 {
12617 }
12618 if (generateRtf)
12619 {
12621 }
12622 if (generateDocbook)
12623 {
12625 }
12626
12628
12629 /**************************************************************************
12630 * Handle Tag Files *
12631 **************************************************************************/
12632
12633 std::shared_ptr<Entry> root = std::make_shared<Entry>();
12634
12635 if (!g_singleComment)
12636 {
12637 msg("Reading and parsing tag files\n");
12638 const StringVector &tagFileList = Config_getList(TAGFILES);
12639 for (const auto &s : tagFileList)
12640 {
12641 readTagFile(root,s.c_str());
12642 }
12643 }
12644
12645 /**************************************************************************
12646 * Parse source files *
12647 **************************************************************************/
12648
12649 addSTLSupport(root);
12650
12651 g_s.begin("Parsing files\n");
12652 if (g_singleComment)
12653 {
12654 //printf("Parsing comment %s\n",qPrint(g_commentFileName));
12655 if (g_commentFileName=="-")
12656 {
12657 std::string text = fileToString(g_commentFileName).str();
12658 addTerminalCharIfMissing(text,'\n');
12659 generateHtmlForComment("stdin.md",text);
12660 }
12661 else if (FileInfo(g_commentFileName.str()).isFile())
12662 {
12663 std::string text;
12665 addTerminalCharIfMissing(text,'\n');
12667 }
12668 else
12669 {
12670 }
12672 exit(0);
12673 }
12674 else
12675 {
12676 if (Config_getInt(NUM_PROC_THREADS)==1)
12677 {
12679 }
12680 else
12681 {
12683 }
12684 }
12685 g_s.end();
12686
12687 /**************************************************************************
12688 * Gather information *
12689 **************************************************************************/
12690
12691 g_s.begin("Building macro definition list...\n");
12693 g_s.end();
12694
12695 g_s.begin("Building group list...\n");
12696 buildGroupList(root.get());
12697 organizeSubGroups(root.get());
12698 g_s.end();
12699
12700 g_s.begin("Building directory list...\n");
12702 findDirDocumentation(root.get());
12703 g_s.end();
12704
12705 g_s.begin("Building namespace list...\n");
12706 buildNamespaceList(root.get());
12707 findUsingDirectives(root.get());
12708 g_s.end();
12709
12710 g_s.begin("Building file list...\n");
12711 buildFileList(root.get());
12712 g_s.end();
12713
12714 g_s.begin("Building class list...\n");
12715 buildClassList(root.get());
12716 g_s.end();
12717
12718 g_s.begin("Building concept list...\n");
12719 buildConceptList(root.get());
12720 g_s.end();
12721
12722 // build list of using declarations here (global list)
12723 buildListOfUsingDecls(root.get());
12724 g_s.end();
12725
12726 g_s.begin("Computing nesting relations for classes...\n");
12728 g_s.end();
12729 // 1.8.2-20121111: no longer add nested classes to the group as well
12730 //distributeClassGroupRelations();
12731
12732 // calling buildClassList may result in cached relations that
12733 // become invalid after resolveClassNestingRelations(), that's why
12734 // we need to clear the cache here
12735 Doxygen::typeLookupCache->clear();
12736 // we don't need the list of using declaration anymore
12737 g_usingDeclarations.clear();
12738
12739 g_s.begin("Associating documentation with classes...\n");
12740 buildClassDocList(root.get());
12741 g_s.end();
12742
12743 g_s.begin("Associating documentation with concepts...\n");
12744 buildConceptDocList(root.get());
12746 g_s.end();
12747
12748 g_s.begin("Associating documentation with modules...\n");
12749 findModuleDocumentation(root.get());
12750 g_s.end();
12751
12752 g_s.begin("Building example list...\n");
12753 buildExampleList(root.get());
12754 g_s.end();
12755
12756 g_s.begin("Searching for enumerations...\n");
12757 findEnums(root.get());
12758 g_s.end();
12759
12760 // Since buildVarList calls isVarWithConstructor
12761 // and this calls getResolvedClass we need to process
12762 // typedefs first so the relations between classes via typedefs
12763 // are properly resolved. See bug 536385 for an example.
12764 g_s.begin("Searching for documented typedefs...\n");
12765 buildTypedefList(root.get());
12766 g_s.end();
12767
12768 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
12769 {
12770 g_s.begin("Searching for documented sequences...\n");
12771 buildSequenceList(root.get());
12772 g_s.end();
12773
12774 g_s.begin("Searching for documented dictionaries...\n");
12775 buildDictionaryList(root.get());
12776 g_s.end();
12777 }
12778
12779 g_s.begin("Searching for members imported via using declarations...\n");
12780 // this should be after buildTypedefList in order to properly import
12781 // used typedefs
12782 findUsingDeclarations(root.get(),TRUE); // do for python packages first
12783 findUsingDeclarations(root.get(),FALSE); // then the rest
12784 g_s.end();
12785
12786 g_s.begin("Searching for included using directives...\n");
12788 g_s.end();
12789
12790 g_s.begin("Searching for documented variables...\n");
12791 buildVarList(root.get());
12792 g_s.end();
12793
12794 g_s.begin("Building interface member list...\n");
12795 buildInterfaceAndServiceList(root.get()); // UNO IDL
12796
12797 g_s.begin("Building member list...\n"); // using class info only !
12798 buildFunctionList(root.get());
12799 g_s.end();
12800
12801 g_s.begin("Searching for friends...\n");
12802 findFriends();
12803 g_s.end();
12804
12805 g_s.begin("Searching for documented defines...\n");
12806 findDefineDocumentation(root.get());
12807 g_s.end();
12808
12809 g_s.begin("Computing class inheritance relations...\n");
12810 findClassEntries(root.get());
12812 g_s.end();
12813
12814 g_s.begin("Computing class usage relations...\n");
12816 g_s.end();
12817
12818 if (Config_getBool(INLINE_SIMPLE_STRUCTS))
12819 {
12820 g_s.begin("Searching for tag less structs...\n");
12822 g_s.end();
12823 }
12824
12825 g_s.begin("Flushing cached template relations that have become invalid...\n");
12827 g_s.end();
12828
12829 g_s.begin("Warn for undocumented namespaces...\n");
12831 g_s.end();
12832
12833 g_s.begin("Computing class relations...\n");
12836 if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
12837 {
12839 }
12841 g_classEntries.clear();
12842 g_s.end();
12843
12844 g_s.begin("Add enum values to enums...\n");
12845 addEnumValuesToEnums(root.get());
12846 findEnumDocumentation(root.get());
12847 g_s.end();
12848
12849 g_s.begin("Searching for member function documentation...\n");
12850 findObjCMethodDefinitions(root.get());
12851 findMemberDocumentation(root.get()); // may introduce new members !
12852 findUsingDeclImports(root.get()); // may introduce new members !
12853 g_usingClassMap.clear();
12857 g_s.end();
12858
12859 // moved to after finding and copying documentation,
12860 // as this introduces new members see bug 722654
12861 g_s.begin("Creating members for template instances...\n");
12863 g_s.end();
12864
12865 g_s.begin("Building page list...\n");
12866 buildPageList(root.get());
12867 g_s.end();
12868
12869 g_s.begin("Search for main page...\n");
12870 findMainPage(root.get());
12871 findMainPageTagFiles(root.get());
12872 g_s.end();
12873
12874 g_s.begin("Computing page relations...\n");
12875 computePageRelations(root.get());
12877 g_s.end();
12878
12879 g_s.begin("Determining the scope of groups...\n");
12880 findGroupScope(root.get());
12881 g_s.end();
12882
12883 g_s.begin("Computing module relations...\n");
12884 auto &mm = ModuleManager::instance();
12885 mm.resolvePartitions();
12886 mm.resolveImports();
12887 mm.collectExportedSymbols();
12888 g_s.end();
12889
12890 auto memberNameComp = [](const MemberNameLinkedMap::Ptr &n1,const MemberNameLinkedMap::Ptr &n2)
12891 {
12892 return qstricmp_sort(n1->memberName().data()+getPrefixIndex(n1->memberName()),
12893 n2->memberName().data()+getPrefixIndex(n2->memberName())
12894 )<0;
12895 };
12896
12897 auto classComp = [](const ClassLinkedMap::Ptr &c1,const ClassLinkedMap::Ptr &c2)
12898 {
12899 if (Config_getBool(SORT_BY_SCOPE_NAME))
12900 {
12901 return qstricmp_sort(c1->name(), c2->name())<0;
12902 }
12903 else
12904 {
12905 int i = qstricmp_sort(c1->className(), c2->className());
12906 return i==0 ? qstricmp_sort(c1->name(), c2->name())<0 : i<0;
12907 }
12908 };
12909
12910 auto namespaceComp = [](const NamespaceLinkedMap::Ptr &n1,const NamespaceLinkedMap::Ptr &n2)
12911 {
12912 return qstricmp_sort(n1->name(),n2->name())<0;
12913 };
12914
12915 auto conceptComp = [](const ConceptLinkedMap::Ptr &c1,const ConceptLinkedMap::Ptr &c2)
12916 {
12917 return qstricmp_sort(c1->name(),c2->name())<0;
12918 };
12919
12920 g_s.begin("Sorting lists...\n");
12921 std::stable_sort(Doxygen::memberNameLinkedMap->begin(),
12923 memberNameComp);
12924 std::stable_sort(Doxygen::functionNameLinkedMap->begin(),
12926 memberNameComp);
12927 std::stable_sort(Doxygen::hiddenClassLinkedMap->begin(),
12929 classComp);
12930 std::stable_sort(Doxygen::classLinkedMap->begin(),
12932 classComp);
12933 std::stable_sort(Doxygen::conceptLinkedMap->begin(),
12935 conceptComp);
12936 std::stable_sort(Doxygen::namespaceLinkedMap->begin(),
12938 namespaceComp);
12939 g_s.end();
12940
12941 g_s.begin("Determining which enums are documented\n");
12943 g_s.end();
12944
12945 g_s.begin("Computing member relations...\n");
12948 g_s.end();
12949
12950 g_s.begin("Building full member lists recursively...\n");
12952 g_s.end();
12953
12954 g_s.begin("Adding members to member groups.\n");
12956 g_s.end();
12957
12958 if (Config_getBool(DISTRIBUTE_GROUP_DOC))
12959 {
12960 g_s.begin("Distributing member group documentation.\n");
12962 g_s.end();
12963 }
12964
12965 g_s.begin("Computing member references...\n");
12967 g_s.end();
12968
12969 if (Config_getBool(INHERIT_DOCS))
12970 {
12971 g_s.begin("Inheriting documentation...\n");
12973 g_s.end();
12974 }
12975
12976
12977 // compute the shortest possible names of all files
12978 // without losing the uniqueness of the file names.
12979 g_s.begin("Generating disk names...\n");
12981 g_s.end();
12982
12983 g_s.begin("Adding source references...\n");
12985 g_s.end();
12986
12987 g_s.begin("Adding xrefitems...\n");
12990 g_s.end();
12991
12992 g_s.begin("Sorting member lists...\n");
12994 g_s.end();
12995
12996 g_s.begin("Setting anonymous enum type...\n");
12998 g_s.end();
12999
13000 g_s.begin("Computing dependencies between directories...\n");
13002 g_s.end();
13003
13004 g_s.begin("Generating citations page...\n");
13006 g_s.end();
13007
13008 g_s.begin("Counting members...\n");
13009 countMembers();
13010 g_s.end();
13011
13012 g_s.begin("Counting data structures...\n");
13014 g_s.end();
13015
13016 g_s.begin("Resolving user defined references...\n");
13018 g_s.end();
13019
13020 g_s.begin("Finding anchors and sections in the documentation...\n");
13022 g_s.end();
13023
13024 g_s.begin("Transferring function references...\n");
13026 g_s.end();
13027
13028 g_s.begin("Combining using relations...\n");
13030 g_s.end();
13031
13033 g_s.begin("Adding members to index pages...\n");
13035 addToIndices();
13036 g_s.end();
13037
13038 g_s.begin("Correcting members for VHDL...\n");
13040 g_s.end();
13041
13042 g_s.begin("Computing tooltip texts...\n");
13044 g_s.end();
13045
13046 if (Config_getBool(SORT_GROUP_NAMES))
13047 {
13048 std::stable_sort(Doxygen::groupLinkedMap->begin(),
13050 [](const auto &g1,const auto &g2)
13051 { return g1->groupTitle() < g2->groupTitle(); });
13052
13053 for (const auto &gd : *Doxygen::groupLinkedMap)
13054 {
13055 gd->sortSubGroups();
13056 }
13057 }
13058
13059 printNavTree(root.get(),0);
13061}
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:5240
void printNavTree(Entry *root, int indent)
Definition doxygen.cpp:9931
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:9358
static void computeTemplateClassRelations()
Definition doxygen.cpp:5334
void printSectionsTree()
Definition doxygen.cpp:9954
static void generateXRefPages()
Definition doxygen.cpp:5506
static void findUsingDeclImports(const Entry *root)
Definition doxygen.cpp:2159
static void findDirDocumentation(const Entry *root)
Definition doxygen.cpp:9595
static void warnUndocumentedNamespaces()
Definition doxygen.cpp:5289
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:5203
static void vhdlCorrectMemberProperties()
Definition doxygen.cpp:8316
static void stopDoxygen(int)
static void computeMemberReferences()
Definition doxygen.cpp:5403
static void transferRelatedFunctionDocumentation()
Definition doxygen.cpp:4361
static void addMembersToMemberGroup()
Definition doxygen.cpp:9223
static void findMainPageTagFiles(Entry *root)
Definition doxygen.cpp:9755
static void distributeConceptGroups()
Definition doxygen.cpp:1299
static void transferFunctionDocumentation()
Definition doxygen.cpp:4280
static void setAnonymousEnumType()
Definition doxygen.cpp:8963
static void sortMemberLists()
Definition doxygen.cpp:8868
static void createTemplateInstanceMembers()
Definition doxygen.cpp:8444
void transferStaticInstanceInitializers()
Definition doxygen.cpp:4410
static void findObjCMethodDefinitions(const Entry *root)
Definition doxygen.cpp:7460
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:9508
static void findMemberDocumentation(const Entry *root)
Definition doxygen.cpp:7430
static void distributeMemberGroupDocumentation()
Definition doxygen.cpp:9261
static void addEnumValuesToEnums(const Entry *root)
Definition doxygen.cpp:7663
static void resolveUserReferences()
Definition doxygen.cpp:9817
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:8977
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:7488
static void addListReferences()
Definition doxygen.cpp:5437
static void exitDoxygen() noexcept
static void addMembersToIndex()
Definition doxygen.cpp:8106
static void findMainPage(Entry *root)
Definition doxygen.cpp:9685
static void findUsingDirectives(const Entry *root)
Definition doxygen.cpp:1851
static void addSourceReferences()
Definition doxygen.cpp:8741
static void buildExampleList(Entry *root)
Definition doxygen.cpp:9902
static void inheritDocumentation()
Definition doxygen.cpp:9163
static void flushUnresolvedRelations()
Definition doxygen.cpp:9412
static QCString g_commentFileName
Definition doxygen.cpp:192
static void findDocumentedEnumValues()
Definition doxygen.cpp:8098
static void findTagLessClasses()
Definition doxygen.cpp:1647
static void generateDiskNames()
static void addToIndices()
Definition doxygen.cpp:8148
static void computeClassRelations()
Definition doxygen.cpp:5309
static void buildFunctionList(const Entry *root)
Definition doxygen.cpp:3878
static void checkPageRelations()
Definition doxygen.cpp:9797
static void findModuleDocumentation(const Entry *root)
Definition doxygen.cpp:1267
static void findEnumDocumentation(const Entry *root)
Definition doxygen.cpp:7986
static void computePageRelations(Entry *root)
Definition doxygen.cpp:9767
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:9658
static void computeVerifiedDotPath()
static bool g_singleComment
Definition doxygen.cpp:193
static void findSectionsInDocumentation()
Definition doxygen.cpp:9299
static void mergeCategories()
Definition doxygen.cpp:8463
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:5273
static void computeTooltipTexts()
Definition doxygen.cpp:8917
static void parseFilesSingleThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void buildCompleteMemberLists()
Definition doxygen.cpp:8485
static void combineUsingRelations()
Definition doxygen.cpp:9198
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:8820
static void buildInterfaceAndServiceList(const Entry *root)
Definition doxygen.cpp:3583
static void computeMemberRelations()
Definition doxygen.cpp:8428
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:5473
QCString fileToString(const QCString &name, bool filter, bool isSourceCode)
Definition util.cpp:1439
int getPrefixIndex(const QCString &name)
Definition util.cpp:3174

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

11458{
11459 QCString versionString = getFullVersion();
11460
11461 // helper that calls \a func to write to file \a fileName via a TextStream
11462 auto writeFile = [](const char *fileName,std::function<void(TextStream&)> func) -> bool
11463 {
11464 std::ofstream f;
11465 if (openOutputFile(fileName,f))
11466 {
11467 TextStream t(&f);
11468 func(t);
11469 return true;
11470 }
11471 return false;
11472 };
11473
11474
11475 /**************************************************************************
11476 * Handle arguments *
11477 **************************************************************************/
11478
11479 int optInd=1;
11480 QCString configName;
11481 QCString traceName;
11482 bool genConfig=false;
11483 bool shortList=false;
11484 bool traceTiming=false;
11486 bool updateConfig=false;
11487 bool quiet = false;
11488 while (optInd<argc && argv[optInd][0]=='-' &&
11489 (isalpha(argv[optInd][1]) || argv[optInd][1]=='?' ||
11490 argv[optInd][1]=='-')
11491 )
11492 {
11493 switch(argv[optInd][1])
11494 {
11495 case 'g':
11496 {
11497 genConfig=TRUE;
11498 }
11499 break;
11500 case 'l':
11501 {
11502 QCString layoutName;
11503 if (optInd+1>=argc)
11504 {
11505 layoutName="DoxygenLayout.xml";
11506 }
11507 else
11508 {
11509 layoutName=argv[optInd+1];
11510 }
11511 writeDefaultLayoutFile(layoutName);
11513 exit(0);
11514 }
11515 break;
11516 case 'c':
11517 if (optInd+1>=argc) // no file name given
11518 {
11519 msg("option \"-c\" is missing the file name to read\n");
11520 devUsage();
11522 exit(1);
11523 }
11524 else
11525 {
11526 g_commentFileName=argv[optInd+1];
11527 optInd++;
11528 }
11529 g_singleComment=true;
11530 quiet=true;
11531 break;
11532 case 'd':
11533 {
11534 QCString debugLabel=getArg(argc,argv,optInd);
11535 if (debugLabel.isEmpty())
11536 {
11537 devUsage();
11539 exit(0);
11540 }
11541 int retVal = Debug::setFlagStr(debugLabel);
11542 if (!retVal)
11543 {
11544 msg("option \"-d\" has unknown debug specifier: \"{}\".\n",debugLabel);
11545 devUsage();
11547 exit(1);
11548 }
11549 }
11550 break;
11551 case 't':
11552 {
11553#if ENABLE_TRACING
11554 if (!strcmp(argv[optInd]+1,"t_time"))
11555 {
11556 traceTiming = true;
11557 }
11558 else if (!strcmp(argv[optInd]+1,"t"))
11559 {
11560 traceTiming = false;
11561 }
11562 else
11563 {
11564 err("option should be \"-t\" or \"-t_time\", found: \"{}\".\n",argv[optInd]);
11566 exit(1);
11567 }
11568 if (optInd+1>=argc || argv[optInd+1][0] == '-') // no file name given
11569 {
11570 traceName="stdout";
11571 }
11572 else
11573 {
11574 traceName=argv[optInd+1];
11575 optInd++;
11576 }
11577#else
11578 err("support for option \"-t\" has not been compiled in (use a debug build or a release build with tracing enabled).\n");
11580 exit(1);
11581#endif
11582 }
11583 break;
11584 case 'x':
11585 if (!strcmp(argv[optInd]+1,"x_noenv")) diffList=Config::CompareMode::CompressedNoEnv;
11586 else if (!strcmp(argv[optInd]+1,"x")) diffList=Config::CompareMode::Compressed;
11587 else
11588 {
11589 err("option should be \"-x\" or \"-x_noenv\", found: \"{}\".\n",argv[optInd]);
11591 exit(1);
11592 }
11593 break;
11594 case 's':
11595 shortList=TRUE;
11596 break;
11597 case 'u':
11598 updateConfig=TRUE;
11599 break;
11600 case 'e':
11601 {
11602 QCString formatName=getArg(argc,argv,optInd);
11603 if (formatName.isEmpty())
11604 {
11605 err("option \"-e\" is missing format specifier rtf.\n");
11607 exit(1);
11608 }
11609 if (qstricmp(formatName.data(),"rtf")==0)
11610 {
11611 if (optInd+1>=argc)
11612 {
11613 err("option \"-e rtf\" is missing an extensions file name\n");
11615 exit(1);
11616 }
11617 writeFile(argv[optInd+1],RTFGenerator::writeExtensionsFile);
11619 exit(0);
11620 }
11621 err("option \"-e\" has invalid format specifier.\n");
11623 exit(1);
11624 }
11625 break;
11626 case 'f':
11627 {
11628 QCString listName=getArg(argc,argv,optInd);
11629 if (listName.isEmpty())
11630 {
11631 err("option \"-f\" is missing list specifier.\n");
11633 exit(1);
11634 }
11635 if (qstricmp(listName.data(),"emoji")==0)
11636 {
11637 if (optInd+1>=argc)
11638 {
11639 err("option \"-f emoji\" is missing an output file name\n");
11641 exit(1);
11642 }
11643 writeFile(argv[optInd+1],[](TextStream &t) { EmojiEntityMapper::instance().writeEmojiFile(t); });
11645 exit(0);
11646 }
11647 err("option \"-f\" has invalid list specifier.\n");
11649 exit(1);
11650 }
11651 break;
11652 case 'w':
11653 {
11654 QCString formatName=getArg(argc,argv,optInd);
11655 if (formatName.isEmpty())
11656 {
11657 err("option \"-w\" is missing format specifier rtf, html or latex\n");
11659 exit(1);
11660 }
11661 if (qstricmp(formatName.data(),"rtf")==0)
11662 {
11663 if (optInd+1>=argc)
11664 {
11665 err("option \"-w rtf\" is missing a style sheet file name\n");
11667 exit(1);
11668 }
11669 if (!writeFile(argv[optInd+1],RTFGenerator::writeStyleSheetFile))
11670 {
11671 err("error opening RTF style sheet file {}!\n",argv[optInd+1]);
11673 exit(1);
11674 }
11676 exit(0);
11677 }
11678 else if (qstricmp(formatName.data(),"html")==0)
11679 {
11680 Config::init();
11681 if (optInd+4<argc || FileInfo("Doxyfile").exists() || FileInfo("doxyfile").exists())
11682 // explicit config file mentioned or default found on disk
11683 {
11684 QCString df = optInd+4<argc ? argv[optInd+4] : (FileInfo("Doxyfile").exists() ? QCString("Doxyfile") : QCString("doxyfile"));
11685 if (!Config::parse(df)) // parse the config file
11686 {
11687 err("error opening or reading configuration file {}!\n",argv[optInd+4]);
11689 exit(1);
11690 }
11691 }
11692 if (optInd+3>=argc)
11693 {
11694 err("option \"-w html\" does not have enough arguments\n");
11696 exit(1);
11697 }
11701 setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
11702 writeFile(argv[optInd+1],[&](TextStream &t) { HtmlGenerator::writeHeaderFile(t,argv[optInd+3]); });
11703 writeFile(argv[optInd+2],HtmlGenerator::writeFooterFile);
11704 writeFile(argv[optInd+3],HtmlGenerator::writeStyleSheetFile);
11706 exit(0);
11707 }
11708 else if (qstricmp(formatName.data(),"latex")==0)
11709 {
11710 Config::init();
11711 if (optInd+4<argc || FileInfo("Doxyfile").exists() || FileInfo("doxyfile").exists())
11712 {
11713 QCString df = optInd+4<argc ? argv[optInd+4] : (FileInfo("Doxyfile").exists() ? QCString("Doxyfile") : QCString("doxyfile"));
11714 if (!Config::parse(df))
11715 {
11716 err("error opening or reading configuration file {}!\n",argv[optInd+4]);
11718 exit(1);
11719 }
11720 }
11721 if (optInd+3>=argc)
11722 {
11723 err("option \"-w latex\" does not have enough arguments\n");
11725 exit(1);
11726 }
11730 setTranslator(Config_getEnum(OUTPUT_LANGUAGE));
11731 writeFile(argv[optInd+1],LatexGenerator::writeHeaderFile);
11732 writeFile(argv[optInd+2],LatexGenerator::writeFooterFile);
11733 writeFile(argv[optInd+3],LatexGenerator::writeStyleSheetFile);
11735 exit(0);
11736 }
11737 else
11738 {
11739 err("Illegal format specifier \"{}\": should be one of rtf, html or latex\n",formatName);
11741 exit(1);
11742 }
11743 }
11744 break;
11745 case 'm':
11747 break;
11748 case 'v':
11749 version(false);
11751 exit(0);
11752 break;
11753 case 'V':
11754 version(true);
11756 exit(0);
11757 break;
11758 case '-':
11759 if (qstrcmp(&argv[optInd][2],"help")==0)
11760 {
11761 usage(argv[0],versionString);
11762 exit(0);
11763 }
11764 else if (qstrcmp(&argv[optInd][2],"version")==0)
11765 {
11766 version(false);
11768 exit(0);
11769 }
11770 else if ((qstrcmp(&argv[optInd][2],"Version")==0) ||
11771 (qstrcmp(&argv[optInd][2],"VERSION")==0))
11772 {
11773 version(true);
11775 exit(0);
11776 }
11777 else
11778 {
11779 err("Unknown option \"-{}\"\n",&argv[optInd][1]);
11780 usage(argv[0],versionString);
11781 exit(1);
11782 }
11783 break;
11784 case 'b':
11785 setvbuf(stdout,nullptr,_IONBF,0);
11786 break;
11787 case 'q':
11788 quiet = true;
11789 break;
11790 case 'h':
11791 case '?':
11792 usage(argv[0],versionString);
11793 exit(0);
11794 break;
11795 default:
11796 err("Unknown option \"-{:c}\"\n",argv[optInd][1]);
11797 usage(argv[0],versionString);
11798 exit(1);
11799 }
11800 optInd++;
11801 }
11802
11803 /**************************************************************************
11804 * Parse or generate the config file *
11805 **************************************************************************/
11806
11807 initTracing(traceName.data(),traceTiming);
11808 TRACE("Doxygen version used: {}",getFullVersion());
11809 Config::init();
11810
11811 FileInfo configFileInfo1("Doxyfile"),configFileInfo2("doxyfile");
11812 if (optInd>=argc)
11813 {
11814 if (configFileInfo1.exists())
11815 {
11816 configName="Doxyfile";
11817 }
11818 else if (configFileInfo2.exists())
11819 {
11820 configName="doxyfile";
11821 }
11822 else if (genConfig)
11823 {
11824 configName="Doxyfile";
11825 }
11826 else
11827 {
11828 err("Doxyfile not found and no input file specified!\n");
11829 usage(argv[0],versionString);
11830 exit(1);
11831 }
11832 }
11833 else
11834 {
11835 FileInfo fi(argv[optInd]);
11836 if (fi.exists() || qstrcmp(argv[optInd],"-")==0 || genConfig)
11837 {
11838 configName=argv[optInd];
11839 }
11840 else
11841 {
11842 err("configuration file {} not found!\n",argv[optInd]);
11843 usage(argv[0],versionString);
11844 exit(1);
11845 }
11846 }
11847
11848 if (genConfig)
11849 {
11850 generateConfigFile(configName,shortList);
11852 exit(0);
11853 }
11854
11855 if (!Config::parse(configName,updateConfig,diffList))
11856 {
11857 err("could not open or read configuration file {}!\n",configName);
11859 exit(1);
11860 }
11861
11862 if (diffList!=Config::CompareMode::Full)
11863 {
11865 compareDoxyfile(diffList);
11867 exit(0);
11868 }
11869
11870 if (updateConfig)
11871 {
11873 generateConfigFile(configName,shortList,TRUE);
11875 exit(0);
11876 }
11877
11878 /* Perlmod wants to know the path to the config file.*/
11879 FileInfo configFileInfo(configName.str());
11880 setPerlModDoxyfile(configFileInfo.absFilePath());
11881
11882 /* handle -q option */
11883 if (quiet) Config_updateBool(QUIET,TRUE);
11884}
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:6233

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

11115{
11116 //printf("killSet count=%d\n",killSet ? (int)killSet->size() : -1);
11117 // strip trailing slashes
11118 if (s.isEmpty()) return;
11119
11120 g_pathsVisited.clear();
11121
11122 FileInfo fi(s.str());
11123 //printf("readFileOrDirectory(%s)\n",s);
11124 {
11125 if (exclSet==nullptr || exclSet->find(fi.absFilePath())==exclSet->end())
11126 {
11127 if (Config_getBool(EXCLUDE_SYMLINKS) && fi.isSymLink())
11128 {
11129 }
11130 else if (!fi.exists() || !fi.isReadable())
11131 {
11132 if (errorIfNotExist)
11133 {
11134 warn_uncond("source '{}' is not a readable file or directory... skipping.\n",s);
11135 }
11136 }
11137 else if (fi.isFile())
11138 {
11139 std::string dirPath = fi.dirPath(true);
11140 std::string filePath = fi.absFilePath();
11141 if (paths && !dirPath.empty())
11142 {
11143 paths->insert(dirPath);
11144 }
11145 //printf("killSet.find(%s)=%d\n",qPrint(fi.absFilePath()),killSet.find(fi.absFilePath())!=killSet.end());
11146 if (killSet==nullptr || killSet->find(filePath)==killSet->end())
11147 {
11148 std::string name=fi.fileName();
11149 if (fnMap)
11150 {
11151 auto fd = createFileDef(dirPath+"/",name);
11152 if (!name.empty())
11153 {
11154 FileName *fn = fnMap->add(name,filePath);
11155 fn->push_back(std::move(fd));
11156 }
11157 }
11158 if (resultList || resultSet)
11159 {
11160 if (resultList) resultList->push_back(filePath);
11161 if (resultSet) resultSet->insert(filePath);
11162 }
11163
11164 if (killSet) killSet->insert(fi.absFilePath());
11165 }
11166 }
11167 else if (fi.isDir()) // readable dir
11168 {
11169 readDir(&fi,fnMap,exclSet,patList,
11170 exclPatList,resultList,resultSet,errorIfNotExist,
11171 recursive,killSet,paths);
11172 }
11173 }
11174 }
11175}
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().