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

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

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

11872{
11873 AUTO_TRACE();
11874
11879}
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 11397 of file doxygen.cpp.

11398{
11402
11403 delete Doxygen::indexList;
11412 Doxygen::mainPage.reset();
11416 Doxygen::globalScope = nullptr;
11418 delete theTranslator;
11419 delete g_outputList;
11420
11425 delete Doxygen::dirLinkedMap;
11426 delete Doxygen::symbolMap;
11427}
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 13047 of file doxygen.cpp.

13048{
13049 AUTO_TRACE();
13050 /**************************************************************************
13051 * Initialize output generators *
13052 **************************************************************************/
13053
13054 /// add extra languages for which we can only produce syntax highlighted code
13056
13057 //// dump all symbols
13058 if (g_dumpSymbolMap)
13059 {
13060 dumpSymbolMap();
13061 exit(0);
13062 }
13063
13064 bool generateHtml = Config_getBool(GENERATE_HTML);
13065 bool generateLatex = Config_getBool(GENERATE_LATEX);
13066 bool generateMan = Config_getBool(GENERATE_MAN);
13067 bool generateRtf = Config_getBool(GENERATE_RTF);
13068 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
13069
13070
13072 if (generateHtml)
13073 {
13077 }
13078 if (generateLatex)
13079 {
13082 }
13083 if (generateDocbook)
13084 {
13087 }
13088 if (generateMan)
13089 {
13090 g_outputList->add<ManGenerator>();
13092 }
13093 if (generateRtf)
13094 {
13095 g_outputList->add<RTFGenerator>();
13097 }
13098 if (Config_getBool(USE_HTAGS))
13099 {
13101 QCString htmldir = Config_getString(HTML_OUTPUT);
13102 if (!Htags::execute(htmldir))
13103 err("USE_HTAGS is YES but htags(1) failed. \n");
13104 else if (!Htags::loadFilemap(htmldir))
13105 err("htags(1) ended normally but failed to load the filemap. \n");
13106 }
13107
13108 /**************************************************************************
13109 * Generate documentation *
13110 **************************************************************************/
13111
13112 g_s.begin("Generating style sheet...\n");
13113 //printf("writing style info\n");
13114 g_outputList->writeStyleInfo(0); // write first part
13115 g_s.end();
13116
13117 bool searchEngine = Config_getBool(SEARCHENGINE);
13118 bool serverBasedSearch = Config_getBool(SERVER_BASED_SEARCH);
13119
13120 g_s.begin("Generating search indices...\n");
13121 if (searchEngine && !serverBasedSearch && generateHtml)
13122 {
13124 }
13125
13126 // generate search indices (need to do this before writing other HTML
13127 // pages as these contain a drop down menu with options depending on
13128 // what categories we find in this function.
13129 if (generateHtml && searchEngine)
13130 {
13131 QCString searchDirName = Config_getString(HTML_OUTPUT)+"/search";
13132 Dir searchDir(searchDirName.str());
13133 if (!searchDir.exists() && !searchDir.mkdir(searchDirName.str()))
13134 {
13135 term("Could not create search results directory '{}' $PWD='{}'\n",
13136 searchDirName,Dir::currentDirPath());
13137 }
13138 HtmlGenerator::writeSearchData(searchDirName);
13139 if (!serverBasedSearch) // client side search index
13140 {
13142 }
13143 }
13144 g_s.end();
13145
13146 // copy static stuff
13147 if (generateHtml)
13148 {
13150 copyLogo(Config_getString(HTML_OUTPUT));
13151 copyIcon(Config_getString(HTML_OUTPUT));
13152 copyExtraFiles(Config_getList(HTML_EXTRA_FILES),"HTML_EXTRA_FILES",Config_getString(HTML_OUTPUT));
13153 }
13154 if (generateLatex)
13155 {
13157 copyLogo(Config_getString(LATEX_OUTPUT));
13158 copyIcon(Config_getString(LATEX_OUTPUT));
13159 copyExtraFiles(Config_getList(LATEX_EXTRA_FILES),"LATEX_EXTRA_FILES",Config_getString(LATEX_OUTPUT));
13160 }
13161 if (generateDocbook)
13162 {
13163 copyLogo(Config_getString(DOCBOOK_OUTPUT));
13164 copyIcon(Config_getString(DOCBOOK_OUTPUT));
13165 }
13166 if (generateRtf)
13167 {
13168 copyLogo(Config_getString(RTF_OUTPUT));
13169 copyIcon(Config_getString(RTF_OUTPUT));
13170 copyExtraFiles(Config_getList(RTF_EXTRA_FILES),"RTF_EXTRA_FILES",Config_getString(RTF_OUTPUT));
13171 }
13172
13174 if (fm.hasFormulas() && generateHtml
13175 && !Config_getBool(USE_MATHJAX))
13176 {
13177 g_s.begin("Generating images for formulas in HTML...\n");
13178 fm.generateImages(Config_getString(HTML_OUTPUT), Config_getEnum(HTML_FORMULA_FORMAT)==HTML_FORMULA_FORMAT_t::svg ?
13180 g_s.end();
13181 }
13182 if (fm.hasFormulas() && generateRtf)
13183 {
13184 g_s.begin("Generating images for formulas in RTF...\n");
13186 g_s.end();
13187 }
13188
13189 if (fm.hasFormulas() && generateDocbook)
13190 {
13191 g_s.begin("Generating images for formulas in Docbook...\n");
13193 g_s.end();
13194 }
13195
13196 g_s.begin("Generating example documentation...\n");
13198 g_s.end();
13199
13200 g_s.begin("Generating file sources...\n");
13202 g_s.end();
13203
13204 g_s.begin("Generating file documentation...\n");
13206 g_s.end();
13207
13208 g_s.begin("Generating page documentation...\n");
13210 g_s.end();
13211
13212 g_s.begin("Generating group documentation...\n");
13214 g_s.end();
13215
13216 g_s.begin("Generating class documentation...\n");
13218 g_s.end();
13219
13220 g_s.begin("Generating concept documentation...\n");
13222 g_s.end();
13223
13224 g_s.begin("Generating module documentation...\n");
13226 g_s.end();
13227
13228 g_s.begin("Generating namespace documentation...\n");
13230 g_s.end();
13231
13232 if (Config_getBool(GENERATE_LEGEND))
13233 {
13234 g_s.begin("Generating graph info page...\n");
13236 g_s.end();
13237 }
13238
13239 g_s.begin("Generating directory documentation...\n");
13241 g_s.end();
13242
13243 if (g_outputList->size()>0)
13244 {
13246 }
13247
13248 g_s.begin("finalizing index lists...\n");
13249 Doxygen::indexList->finalize();
13250 g_s.end();
13251
13252 g_s.begin("writing tag file...\n");
13253 writeTagFile();
13254 g_s.end();
13255
13256 if (Config_getBool(GENERATE_XML))
13257 {
13258 g_s.begin("Generating XML output...\n");
13260 generateXML();
13262 g_s.end();
13263 }
13264 if (Config_getBool(GENERATE_SQLITE3))
13265 {
13266 g_s.begin("Generating SQLITE3 output...\n");
13268 g_s.end();
13269 }
13270
13271 if (Config_getBool(GENERATE_AUTOGEN_DEF))
13272 {
13273 g_s.begin("Generating AutoGen DEF output...\n");
13274 generateDEF();
13275 g_s.end();
13276 }
13277 if (Config_getBool(GENERATE_PERLMOD))
13278 {
13279 g_s.begin("Generating Perl module output...\n");
13281 g_s.end();
13282 }
13283 if (generateHtml && searchEngine && serverBasedSearch)
13284 {
13285 g_s.begin("Generating search index\n");
13286 if (Doxygen::searchIndex.kind()==SearchIndexIntf::Internal) // write own search index
13287 {
13289 Doxygen::searchIndex.write(Config_getString(HTML_OUTPUT)+"/search/search.idx");
13290 }
13291 else // write data for external search index
13292 {
13294 QCString searchDataFile = Config_getString(SEARCHDATA_FILE);
13295 if (searchDataFile.isEmpty())
13296 {
13297 searchDataFile="searchdata.xml";
13298 }
13299 if (!Portable::isAbsolutePath(searchDataFile.data()))
13300 {
13301 searchDataFile.prepend(Config_getString(OUTPUT_DIRECTORY)+"/");
13302 }
13303 Doxygen::searchIndex.write(searchDataFile);
13304 }
13305 g_s.end();
13306 }
13307
13308 if (generateRtf)
13309 {
13310 g_s.begin("Combining RTF output...\n");
13311 if (!RTFGenerator::preProcessFileInplace(Config_getString(RTF_OUTPUT),"refman.rtf"))
13312 {
13313 err("An error occurred during post-processing the RTF files!\n");
13314 }
13315 g_s.end();
13316 }
13317
13318 g_s.begin("Running plantuml with JAVA...\n");
13320 g_s.end();
13321
13322 if (Config_getBool(HAVE_DOT))
13323 {
13324 g_s.begin("Running dot...\n");
13326 g_s.end();
13327 }
13328
13329 if (generateHtml &&
13330 Config_getBool(GENERATE_HTMLHELP) &&
13331 !Config_getString(HHC_LOCATION).isEmpty())
13332 {
13333 g_s.begin("Running html help compiler...\n");
13335 g_s.end();
13336 }
13337
13338 if ( generateHtml &&
13339 Config_getBool(GENERATE_QHP) &&
13340 !Config_getString(QHG_LOCATION).isEmpty())
13341 {
13342 g_s.begin("Running qhelpgenerator...\n");
13344 g_s.end();
13345 }
13346
13347 g_outputList->cleanup();
13348
13349 msg("type lookup cache used {}/{} hits={} misses={}\n",
13351 Doxygen::typeLookupCache->capacity(),
13353 Doxygen::typeLookupCache->misses());
13354 msg("symbol lookup cache used {}/{} hits={} misses={}\n",
13356 Doxygen::symbolLookupCache->capacity(),
13358 Doxygen::symbolLookupCache->misses());
13359 int typeCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::typeLookupCache->misses()*2/3)); // part of the cache is flushed, hence the 2/3 correction factor
13360 int symbolCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::symbolLookupCache->misses()));
13361 int cacheParam = std::max(typeCacheParam,symbolCacheParam);
13362 if (cacheParam>Config_getInt(LOOKUP_CACHE_SIZE))
13363 {
13364 msg("Note: based on cache misses the ideal setting for LOOKUP_CACHE_SIZE is {} at the cost of higher memory usage.\n",cacheParam);
13365 }
13366
13368 {
13369
13370 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
13371 if (numThreads<1) numThreads=1;
13372 msg("Total elapsed time: {:.6f} seconds\n(of which an average of {:.6f} seconds per thread waiting for external tools to finish)\n",
13373 (static_cast<double>(Debug::elapsedTime())),
13374 Portable::getSysElapsedTime()/static_cast<double>(numThreads)
13375 );
13376 g_s.print();
13377
13379 msg("finished...\n");
13381 }
13382 else
13383 {
13384 msg("finished...\n");
13385 }
13386
13387
13388 /**************************************************************************
13389 * Start cleaning up *
13390 **************************************************************************/
13391
13393
13395 Dir thisDir;
13396 thisDir.remove(Doxygen::filterDBFileName.str());
13398 exitTracing();
13400 delete Doxygen::clangUsrMap;
13402
13403 //dumpDocNodeSizes();
13404}
@ 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:201
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:1202
static void writeSearchPage()
Definition htmlgen.cpp:3169
static void writeTabData()
Additional initialization after indices have been created.
Definition htmlgen.cpp:1353
static void writeSearchData(const QCString &dir)
Definition htmlgen.cpp:1362
static void writeExternalSearchPage()
Definition htmlgen.cpp:3268
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:314
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:1176
static void copyLatexStyleSheet()
static void runQHelpGenerator()
class Statistics g_s
static void copyStyleSheet()
static void generateGroupDocs()
Definition doxygen.cpp:9999
static void generateExampleDocs()
Definition doxygen.cpp:9955
static void dumpSymbolMap()
static void generateFileDocs()
Definition doxygen.cpp:8664
static void copyIcon(const QCString &outputOption)
static void generatePageDocs()
Definition doxygen.cpp:9870
static void generateFileSources()
Definition doxygen.cpp:8498
static void copyLogo(const QCString &outputOption)
static void generateClassDocs()
Definition doxygen.cpp:9099
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:9125
void writeGraphInfo(OutputList &ol)
Definition index.cpp:4063
void writeIndexHierarchy(OutputList &ol)
Definition index.cpp:5758
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:5718
void generateXML()
Definition xmlgen.cpp:2204

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

11329{
11330 initResources();
11331 QCString lang = Portable::getenv("LC_ALL");
11332 if (!lang.isEmpty()) Portable::setenv("LANG",lang);
11333 std::setlocale(LC_ALL,"");
11334 std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
11335 std::setlocale(LC_NUMERIC,"C");
11336
11338
11362
11363 // register any additional parsers here...
11364
11366
11367#if USE_LIBCLANG
11369#endif
11378 Doxygen::pageLinkedMap = new PageLinkedMap; // all doc pages
11379 Doxygen::exampleLinkedMap = new PageLinkedMap; // all examples
11380 //Doxygen::tagDestinationDict.setAutoDelete(TRUE);
11382
11383 // initialization of these globals depends on
11384 // configuration switches so we need to postpone these
11385 Doxygen::globalScope = nullptr;
11394
11395}
static void startTimer()
Definition debug.cpp:196
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:5651

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

12373{
12374 AUTO_TRACE();
12375 std::atexit(exitDoxygen);
12376
12377 Portable::correctPath(Config_getList(EXTERNAL_TOOL_PATH));
12378
12379#if USE_LIBCLANG
12380 Doxygen::clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
12381#endif
12382
12383 // we would like to show the versionString earlier, but we first have to handle the configuration file
12384 // to know the value of the QUIET setting.
12385 QCString versionString = getFullVersion();
12386 msg("Doxygen version used: {}\n",versionString);
12387
12389
12390 /**************************************************************************
12391 * Make sure the output directory exists
12392 **************************************************************************/
12393 QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
12394 if (!g_singleComment)
12395 {
12396 if (outputDirectory.isEmpty())
12397 {
12398 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,Dir::currentDirPath());
12399 }
12400 else
12401 {
12402 Dir dir(outputDirectory.str());
12403 if (!dir.exists())
12404 {
12405 dir.setPath(Dir::currentDirPath());
12406 if (!dir.mkdir(outputDirectory.str()))
12407 {
12408 term("tag OUTPUT_DIRECTORY: Output directory '{}' does not "
12409 "exist and cannot be created\n",outputDirectory);
12410 }
12411 else
12412 {
12413 msg("Notice: Output directory '{}' does not exist. "
12414 "I have created it for you.\n", outputDirectory);
12415 }
12416 dir.setPath(outputDirectory.str());
12417 }
12418 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,dir.absPath());
12419 }
12420 }
12421 AUTO_TRACE_ADD("outputDirectory={}",outputDirectory);
12422
12423 /**************************************************************************
12424 * Initialize global lists and dictionaries
12425 **************************************************************************/
12426
12427 // also scale lookup cache with SYMBOL_CACHE_SIZE
12428 int cacheSize = Config_getInt(LOOKUP_CACHE_SIZE);
12429 if (cacheSize<0) cacheSize=0;
12430 if (cacheSize>9) cacheSize=9;
12431 uint32_t lookupSize = 65536 << cacheSize;
12434
12435#ifdef HAS_SIGNALS
12436 signal(SIGINT, stopDoxygen);
12437#endif
12438
12439 uint32_t pid = Portable::pid();
12440 Doxygen::filterDBFileName.sprintf("doxygen_filterdb_%d.tmp",pid);
12441 Doxygen::filterDBFileName.prepend(outputDirectory+"/");
12442
12443 /**************************************************************************
12444 * Check/create output directories *
12445 **************************************************************************/
12446
12447 bool generateHtml = Config_getBool(GENERATE_HTML);
12448 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
12449 bool generateXml = Config_getBool(GENERATE_XML);
12450 bool generateLatex = Config_getBool(GENERATE_LATEX);
12451 bool generateRtf = Config_getBool(GENERATE_RTF);
12452 bool generateMan = Config_getBool(GENERATE_MAN);
12453 bool generateSql = Config_getBool(GENERATE_SQLITE3);
12454 QCString htmlOutput;
12455 QCString docbookOutput;
12456 QCString xmlOutput;
12457 QCString latexOutput;
12458 QCString rtfOutput;
12459 QCString manOutput;
12460 QCString sqlOutput;
12461
12462 if (!g_singleComment)
12463 {
12464 if (generateHtml)
12465 {
12466 htmlOutput = createOutputDirectory(outputDirectory,Config_getString(HTML_OUTPUT),"/html");
12467 Config_updateString(HTML_OUTPUT,htmlOutput);
12468
12469 QCString sitemapUrl = Config_getString(SITEMAP_URL);
12470 bool generateSitemap = !sitemapUrl.isEmpty();
12471 if (generateSitemap && !sitemapUrl.endsWith("/"))
12472 {
12473 Config_updateString(SITEMAP_URL,sitemapUrl+"/");
12474 }
12475
12476 // add HTML indexers that are enabled
12477 bool generateHtmlHelp = Config_getBool(GENERATE_HTMLHELP);
12478 bool generateEclipseHelp = Config_getBool(GENERATE_ECLIPSEHELP);
12479 bool generateQhp = Config_getBool(GENERATE_QHP);
12480 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
12481 bool generateDocSet = Config_getBool(GENERATE_DOCSET);
12482 if (generateEclipseHelp) Doxygen::indexList->addIndex<EclipseHelp>();
12483 if (generateHtmlHelp) Doxygen::indexList->addIndex<HtmlHelp>();
12484 if (generateQhp) Doxygen::indexList->addIndex<Qhp>();
12485 if (generateSitemap) Doxygen::indexList->addIndex<Sitemap>();
12486 if (generateTreeView) Doxygen::indexList->addIndex<FTVHelp>(TRUE);
12487 if (generateDocSet) Doxygen::indexList->addIndex<DocSets>();
12488 Doxygen::indexList->addIndex<Crawlmap>();
12489 Doxygen::indexList->initialize();
12490 }
12491
12492 if (generateDocbook)
12493 {
12494 docbookOutput = createOutputDirectory(outputDirectory,Config_getString(DOCBOOK_OUTPUT),"/docbook");
12495 Config_updateString(DOCBOOK_OUTPUT,docbookOutput);
12496 }
12497
12498 if (generateXml)
12499 {
12500 xmlOutput = createOutputDirectory(outputDirectory,Config_getString(XML_OUTPUT),"/xml");
12501 Config_updateString(XML_OUTPUT,xmlOutput);
12502 }
12503
12504 if (generateLatex)
12505 {
12506 latexOutput = createOutputDirectory(outputDirectory,Config_getString(LATEX_OUTPUT), "/latex");
12507 Config_updateString(LATEX_OUTPUT,latexOutput);
12508 }
12509
12510 if (generateRtf)
12511 {
12512 rtfOutput = createOutputDirectory(outputDirectory,Config_getString(RTF_OUTPUT),"/rtf");
12513 Config_updateString(RTF_OUTPUT,rtfOutput);
12514 }
12515
12516 if (generateMan)
12517 {
12518 manOutput = createOutputDirectory(outputDirectory,Config_getString(MAN_OUTPUT),"/man");
12519 Config_updateString(MAN_OUTPUT,manOutput);
12520 }
12521
12522 if (generateSql)
12523 {
12524 sqlOutput = createOutputDirectory(outputDirectory,Config_getString(SQLITE3_OUTPUT),"/sqlite3");
12525 Config_updateString(SQLITE3_OUTPUT,sqlOutput);
12526 }
12527 }
12528
12529 if (Config_getBool(HAVE_DOT))
12530 {
12531 QCString curFontPath = Config_getString(DOT_FONTPATH);
12532 if (curFontPath.isEmpty())
12533 {
12534 Portable::getenv("DOTFONTPATH");
12535 QCString newFontPath = ".";
12536 if (!curFontPath.isEmpty())
12537 {
12538 newFontPath+=Portable::pathListSeparator();
12539 newFontPath+=curFontPath;
12540 }
12541 Portable::setenv("DOTFONTPATH",qPrint(newFontPath));
12542 }
12543 else
12544 {
12545 Portable::setenv("DOTFONTPATH",qPrint(curFontPath));
12546 }
12547 }
12548
12549 /**************************************************************************
12550 * Handle layout file *
12551 **************************************************************************/
12552
12554 QCString layoutFileName = Config_getString(LAYOUT_FILE);
12555 bool defaultLayoutUsed = FALSE;
12556 if (layoutFileName.isEmpty())
12557 {
12558 layoutFileName = Config_updateString(LAYOUT_FILE,"DoxygenLayout.xml");
12559 defaultLayoutUsed = TRUE;
12560 }
12561 AUTO_TRACE_ADD("defaultLayoutUsed={}, layoutFileName={}",defaultLayoutUsed,layoutFileName);
12562
12563 FileInfo fi(layoutFileName.str());
12564 if (fi.exists())
12565 {
12566 msg("Parsing layout file {}...\n",layoutFileName);
12567 LayoutDocManager::instance().parse(layoutFileName);
12568 }
12569 else if (!defaultLayoutUsed)
12570 {
12571 warn_uncond("failed to open layout file '{}' for reading! Using default settings.\n",layoutFileName);
12572 }
12573 printLayout();
12574
12575 /**************************************************************************
12576 * Read and preprocess input *
12577 **************************************************************************/
12578
12579 // prevent search in the output directories
12580 StringVector exclPatterns = Config_getList(EXCLUDE_PATTERNS);
12581 if (generateHtml) exclPatterns.push_back(htmlOutput.str());
12582 if (generateDocbook) exclPatterns.push_back(docbookOutput.str());
12583 if (generateXml) exclPatterns.push_back(xmlOutput.str());
12584 if (generateLatex) exclPatterns.push_back(latexOutput.str());
12585 if (generateRtf) exclPatterns.push_back(rtfOutput.str());
12586 if (generateMan) exclPatterns.push_back(manOutput.str());
12587 Config_updateList(EXCLUDE_PATTERNS,exclPatterns);
12588
12589 if (!g_singleComment)
12590 {
12592
12594 }
12595
12596 // Notice: the order of the function calls below is very important!
12597
12598 if (generateHtml && !Config_getBool(USE_MATHJAX))
12599 {
12601 }
12602 if (generateRtf)
12603 {
12605 }
12606 if (generateDocbook)
12607 {
12609 }
12610
12612
12613 /**************************************************************************
12614 * Handle Tag Files *
12615 **************************************************************************/
12616
12617 std::shared_ptr<Entry> root = std::make_shared<Entry>();
12618
12619 if (!g_singleComment)
12620 {
12621 msg("Reading and parsing tag files\n");
12622 const StringVector &tagFileList = Config_getList(TAGFILES);
12623 for (const auto &s : tagFileList)
12624 {
12625 readTagFile(root,s.c_str());
12626 }
12627 }
12628
12629 /**************************************************************************
12630 * Parse source files *
12631 **************************************************************************/
12632
12633 addSTLSupport(root);
12634
12635 g_s.begin("Parsing files\n");
12636 if (g_singleComment)
12637 {
12638 //printf("Parsing comment %s\n",qPrint(g_commentFileName));
12639 if (g_commentFileName=="-")
12640 {
12641 std::string text = fileToString(g_commentFileName).str();
12642 addTerminalCharIfMissing(text,'\n');
12643 generateHtmlForComment("stdin.md",text);
12644 }
12645 else if (FileInfo(g_commentFileName.str()).isFile())
12646 {
12647 std::string text;
12649 addTerminalCharIfMissing(text,'\n');
12651 }
12652 else
12653 {
12654 }
12656 exit(0);
12657 }
12658 else
12659 {
12660 if (Config_getInt(NUM_PROC_THREADS)==1)
12661 {
12663 }
12664 else
12665 {
12667 }
12668 }
12669 g_s.end();
12670
12671 /**************************************************************************
12672 * Gather information *
12673 **************************************************************************/
12674
12675 g_s.begin("Building macro definition list...\n");
12677 g_s.end();
12678
12679 g_s.begin("Building group list...\n");
12680 buildGroupList(root.get());
12681 organizeSubGroups(root.get());
12682 g_s.end();
12683
12684 g_s.begin("Building directory list...\n");
12686 findDirDocumentation(root.get());
12687 g_s.end();
12688
12689 g_s.begin("Building namespace list...\n");
12690 buildNamespaceList(root.get());
12691 findUsingDirectives(root.get());
12692 g_s.end();
12693
12694 g_s.begin("Building file list...\n");
12695 buildFileList(root.get());
12696 g_s.end();
12697
12698 g_s.begin("Building class list...\n");
12699 buildClassList(root.get());
12700 g_s.end();
12701
12702 g_s.begin("Building concept list...\n");
12703 buildConceptList(root.get());
12704 g_s.end();
12705
12706 // build list of using declarations here (global list)
12707 buildListOfUsingDecls(root.get());
12708 g_s.end();
12709
12710 g_s.begin("Computing nesting relations for classes...\n");
12712 g_s.end();
12713 // 1.8.2-20121111: no longer add nested classes to the group as well
12714 //distributeClassGroupRelations();
12715
12716 // calling buildClassList may result in cached relations that
12717 // become invalid after resolveClassNestingRelations(), that's why
12718 // we need to clear the cache here
12719 Doxygen::typeLookupCache->clear();
12720 // we don't need the list of using declaration anymore
12721 g_usingDeclarations.clear();
12722
12723 g_s.begin("Associating documentation with classes...\n");
12724 buildClassDocList(root.get());
12725 g_s.end();
12726
12727 g_s.begin("Associating documentation with concepts...\n");
12728 buildConceptDocList(root.get());
12730 g_s.end();
12731
12732 g_s.begin("Associating documentation with modules...\n");
12733 findModuleDocumentation(root.get());
12734 g_s.end();
12735
12736 g_s.begin("Building example list...\n");
12737 buildExampleList(root.get());
12738 g_s.end();
12739
12740 g_s.begin("Searching for enumerations...\n");
12741 findEnums(root.get());
12742 g_s.end();
12743
12744 // Since buildVarList calls isVarWithConstructor
12745 // and this calls getResolvedClass we need to process
12746 // typedefs first so the relations between classes via typedefs
12747 // are properly resolved. See bug 536385 for an example.
12748 g_s.begin("Searching for documented typedefs...\n");
12749 buildTypedefList(root.get());
12750 g_s.end();
12751
12752 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
12753 {
12754 g_s.begin("Searching for documented sequences...\n");
12755 buildSequenceList(root.get());
12756 g_s.end();
12757
12758 g_s.begin("Searching for documented dictionaries...\n");
12759 buildDictionaryList(root.get());
12760 g_s.end();
12761 }
12762
12763 g_s.begin("Searching for members imported via using declarations...\n");
12764 // this should be after buildTypedefList in order to properly import
12765 // used typedefs
12766 findUsingDeclarations(root.get(),TRUE); // do for python packages first
12767 findUsingDeclarations(root.get(),FALSE); // then the rest
12768 g_s.end();
12769
12770 g_s.begin("Searching for included using directives...\n");
12772 g_s.end();
12773
12774 g_s.begin("Searching for documented variables...\n");
12775 buildVarList(root.get());
12776 g_s.end();
12777
12778 g_s.begin("Building interface member list...\n");
12779 buildInterfaceAndServiceList(root.get()); // UNO IDL
12780
12781 g_s.begin("Building member list...\n"); // using class info only !
12782 buildFunctionList(root.get());
12783 g_s.end();
12784
12785 g_s.begin("Searching for friends...\n");
12786 findFriends();
12787 g_s.end();
12788
12789 g_s.begin("Searching for documented defines...\n");
12790 findDefineDocumentation(root.get());
12791 g_s.end();
12792
12793 g_s.begin("Computing class inheritance relations...\n");
12794 findClassEntries(root.get());
12796 g_s.end();
12797
12798 g_s.begin("Computing class usage relations...\n");
12800 g_s.end();
12801
12802 if (Config_getBool(INLINE_SIMPLE_STRUCTS))
12803 {
12804 g_s.begin("Searching for tag less structs...\n");
12806 g_s.end();
12807 }
12808
12809 g_s.begin("Flushing cached template relations that have become invalid...\n");
12811 g_s.end();
12812
12813 g_s.begin("Warn for undocumented namespaces...\n");
12815 g_s.end();
12816
12817 g_s.begin("Computing class relations...\n");
12820 if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
12821 {
12823 }
12825 g_classEntries.clear();
12826 g_s.end();
12827
12828 g_s.begin("Add enum values to enums...\n");
12829 addEnumValuesToEnums(root.get());
12830 findEnumDocumentation(root.get());
12831 g_s.end();
12832
12833 g_s.begin("Searching for member function documentation...\n");
12834 findObjCMethodDefinitions(root.get());
12835 findMemberDocumentation(root.get()); // may introduce new members !
12836 findUsingDeclImports(root.get()); // may introduce new members !
12837 g_usingClassMap.clear();
12841 g_s.end();
12842
12843 // moved to after finding and copying documentation,
12844 // as this introduces new members see bug 722654
12845 g_s.begin("Creating members for template instances...\n");
12847 g_s.end();
12848
12849 g_s.begin("Building page list...\n");
12850 buildPageList(root.get());
12851 g_s.end();
12852
12853 g_s.begin("Search for main page...\n");
12854 findMainPage(root.get());
12855 findMainPageTagFiles(root.get());
12856 g_s.end();
12857
12858 g_s.begin("Computing page relations...\n");
12859 computePageRelations(root.get());
12861 g_s.end();
12862
12863 g_s.begin("Determining the scope of groups...\n");
12864 findGroupScope(root.get());
12865 g_s.end();
12866
12867 g_s.begin("Computing module relations...\n");
12868 auto &mm = ModuleManager::instance();
12869 mm.resolvePartitions();
12870 mm.resolveImports();
12871 mm.collectExportedSymbols();
12872 g_s.end();
12873
12874 auto memberNameComp = [](const MemberNameLinkedMap::Ptr &n1,const MemberNameLinkedMap::Ptr &n2)
12875 {
12876 return qstricmp_sort(n1->memberName().data()+getPrefixIndex(n1->memberName()),
12877 n2->memberName().data()+getPrefixIndex(n2->memberName())
12878 )<0;
12879 };
12880
12881 auto classComp = [](const ClassLinkedMap::Ptr &c1,const ClassLinkedMap::Ptr &c2)
12882 {
12883 if (Config_getBool(SORT_BY_SCOPE_NAME))
12884 {
12885 return qstricmp_sort(c1->name(), c2->name())<0;
12886 }
12887 else
12888 {
12889 int i = qstricmp_sort(c1->className(), c2->className());
12890 return i==0 ? qstricmp_sort(c1->name(), c2->name())<0 : i<0;
12891 }
12892 };
12893
12894 auto namespaceComp = [](const NamespaceLinkedMap::Ptr &n1,const NamespaceLinkedMap::Ptr &n2)
12895 {
12896 return qstricmp_sort(n1->name(),n2->name())<0;
12897 };
12898
12899 auto conceptComp = [](const ConceptLinkedMap::Ptr &c1,const ConceptLinkedMap::Ptr &c2)
12900 {
12901 return qstricmp_sort(c1->name(),c2->name())<0;
12902 };
12903
12904 g_s.begin("Sorting lists...\n");
12905 std::stable_sort(Doxygen::memberNameLinkedMap->begin(),
12907 memberNameComp);
12908 std::stable_sort(Doxygen::functionNameLinkedMap->begin(),
12910 memberNameComp);
12911 std::stable_sort(Doxygen::hiddenClassLinkedMap->begin(),
12913 classComp);
12914 std::stable_sort(Doxygen::classLinkedMap->begin(),
12916 classComp);
12917 std::stable_sort(Doxygen::conceptLinkedMap->begin(),
12919 conceptComp);
12920 std::stable_sort(Doxygen::namespaceLinkedMap->begin(),
12922 namespaceComp);
12923 g_s.end();
12924
12925 g_s.begin("Determining which enums are documented\n");
12927 g_s.end();
12928
12929 g_s.begin("Computing member relations...\n");
12932 g_s.end();
12933
12934 g_s.begin("Building full member lists recursively...\n");
12936 g_s.end();
12937
12938 g_s.begin("Adding members to member groups.\n");
12940 g_s.end();
12941
12942 if (Config_getBool(DISTRIBUTE_GROUP_DOC))
12943 {
12944 g_s.begin("Distributing member group documentation.\n");
12946 g_s.end();
12947 }
12948
12949 g_s.begin("Computing member references...\n");
12951 g_s.end();
12952
12953 if (Config_getBool(INHERIT_DOCS))
12954 {
12955 g_s.begin("Inheriting documentation...\n");
12957 g_s.end();
12958 }
12959
12960
12961 // compute the shortest possible names of all files
12962 // without losing the uniqueness of the file names.
12963 g_s.begin("Generating disk names...\n");
12965 g_s.end();
12966
12967 g_s.begin("Adding source references...\n");
12969 g_s.end();
12970
12971 g_s.begin("Adding xrefitems...\n");
12974 g_s.end();
12975
12976 g_s.begin("Sorting member lists...\n");
12978 g_s.end();
12979
12980 g_s.begin("Setting anonymous enum type...\n");
12982 g_s.end();
12983
12984 g_s.begin("Computing dependencies between directories...\n");
12986 g_s.end();
12987
12988 g_s.begin("Generating citations page...\n");
12990 g_s.end();
12991
12992 g_s.begin("Counting members...\n");
12993 countMembers();
12994 g_s.end();
12995
12996 g_s.begin("Counting data structures...\n");
12998 g_s.end();
12999
13000 g_s.begin("Resolving user defined references...\n");
13002 g_s.end();
13003
13004 g_s.begin("Finding anchors and sections in the documentation...\n");
13006 g_s.end();
13007
13008 g_s.begin("Transferring function references...\n");
13010 g_s.end();
13011
13012 g_s.begin("Combining using relations...\n");
13014 g_s.end();
13015
13017 g_s.begin("Adding members to index pages...\n");
13019 addToIndices();
13020 g_s.end();
13021
13022 g_s.begin("Correcting members for VHDL...\n");
13024 g_s.end();
13025
13026 g_s.begin("Computing tooltip texts...\n");
13028 g_s.end();
13029
13030 if (Config_getBool(SORT_GROUP_NAMES))
13031 {
13032 std::stable_sort(Doxygen::groupLinkedMap->begin(),
13034 [](const auto &g1,const auto &g2)
13035 { return g1->groupTitle() < g2->groupTitle(); });
13036
13037 for (const auto &gd : *Doxygen::groupLinkedMap)
13038 {
13039 gd->sortSubGroups();
13040 }
13041 }
13042
13043 printNavTree(root.get(),0);
13045}
Definition cache.h:32
static CitationManager & instance()
Definition cite.cpp:86
void generatePage()
Generate the citations page.
Definition cite.cpp:333
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:1435
void parse(const QCString &fileName, const char *data=nullptr)
Parses a user provided layout.
Definition layout.cpp:1468
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:1085
void computeDirDependencies()
Definition dirdef.cpp:1159
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:47
static void findInheritedTemplateInstances()
Definition doxygen.cpp:5243
void printNavTree(Entry *root, int indent)
Definition doxygen.cpp:9916
static void buildGroupList(const Entry *root)
Definition doxygen.cpp:425
static void findUsingDeclarations(const Entry *root, bool filterPythonPackages)
Definition doxygen.cpp:2005
static void flushCachedTemplateRelations()
Definition doxygen.cpp:9341
static void computeTemplateClassRelations()
Definition doxygen.cpp:5337
void printSectionsTree()
Definition doxygen.cpp:9939
static void generateXRefPages()
Definition doxygen.cpp:5509
static void findUsingDeclImports(const Entry *root)
Definition doxygen.cpp:2158
static void findDirDocumentation(const Entry *root)
Definition doxygen.cpp:9580
static void warnUndocumentedNamespaces()
Definition doxygen.cpp:5292
static void buildConceptList(const Entry *root)
Definition doxygen.cpp:1276
static void resolveClassNestingRelations()
Definition doxygen.cpp:1331
static void findClassEntries(const Entry *root)
Definition doxygen.cpp:5206
static void vhdlCorrectMemberProperties()
Definition doxygen.cpp:8299
static void stopDoxygen(int)
static void computeMemberReferences()
Definition doxygen.cpp:5406
static void transferRelatedFunctionDocumentation()
Definition doxygen.cpp:4362
static void addMembersToMemberGroup()
Definition doxygen.cpp:9206
static void findMainPageTagFiles(Entry *root)
Definition doxygen.cpp:9740
static void distributeConceptGroups()
Definition doxygen.cpp:1298
static void transferFunctionDocumentation()
Definition doxygen.cpp:4281
static void setAnonymousEnumType()
Definition doxygen.cpp:8946
static void sortMemberLists()
Definition doxygen.cpp:8851
static void createTemplateInstanceMembers()
Definition doxygen.cpp:8427
void transferStaticInstanceInitializers()
Definition doxygen.cpp:4411
static void findObjCMethodDefinitions(const Entry *root)
Definition doxygen.cpp:7443
static void buildTypedefList(const Entry *root)
Definition doxygen.cpp:3352
static void findGroupScope(const Entry *root)
Definition doxygen.cpp:440
static void findDefineDocumentation(Entry *root)
Definition doxygen.cpp:9493
static void findMemberDocumentation(const Entry *root)
Definition doxygen.cpp:7413
static void distributeMemberGroupDocumentation()
Definition doxygen.cpp:9244
static void addEnumValuesToEnums(const Entry *root)
Definition doxygen.cpp:7646
static void resolveUserReferences()
Definition doxygen.cpp:9802
static void buildVarList(const Entry *root)
Definition doxygen.cpp:3488
static void buildSequenceList(const Entry *root)
Definition doxygen.cpp:3451
static void buildNamespaceList(const Entry *root)
Definition doxygen.cpp:1670
static void readTagFile(const std::shared_ptr< Entry > &root, const QCString &tagLine)
static void findIncludedUsingDirectives()
Definition doxygen.cpp:2408
static void countMembers()
Definition doxygen.cpp:8960
static void organizeSubGroups(const Entry *root)
Definition doxygen.cpp:484
void searchInputFiles()
static void findFriends()
Definition doxygen.cpp:4184
static void findEnums(const Entry *root)
Definition doxygen.cpp:7471
static void addListReferences()
Definition doxygen.cpp:5440
static void exitDoxygen() noexcept
static void addMembersToIndex()
Definition doxygen.cpp:8089
static void findMainPage(Entry *root)
Definition doxygen.cpp:9670
static void findUsingDirectives(const Entry *root)
Definition doxygen.cpp:1850
static void addSourceReferences()
Definition doxygen.cpp:8724
static void buildExampleList(Entry *root)
Definition doxygen.cpp:9887
static void inheritDocumentation()
Definition doxygen.cpp:9146
static void flushUnresolvedRelations()
Definition doxygen.cpp:9395
static QCString g_commentFileName
Definition doxygen.cpp:192
static void findDocumentedEnumValues()
Definition doxygen.cpp:8081
static void findTagLessClasses()
Definition doxygen.cpp:1646
static void generateDiskNames()
static void addToIndices()
Definition doxygen.cpp:8131
static void computeClassRelations()
Definition doxygen.cpp:5312
static void buildFunctionList(const Entry *root)
Definition doxygen.cpp:3878
static void checkPageRelations()
Definition doxygen.cpp:9782
static void findModuleDocumentation(const Entry *root)
Definition doxygen.cpp:1266
static void findEnumDocumentation(const Entry *root)
Definition doxygen.cpp:7969
static void computePageRelations(Entry *root)
Definition doxygen.cpp:9752
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:3469
static void buildClassDocList(const Entry *root)
Definition doxygen.cpp:1137
static void buildPageList(Entry *root)
Definition doxygen.cpp:9643
static void computeVerifiedDotPath()
static bool g_singleComment
Definition doxygen.cpp:193
static void findSectionsInDocumentation()
Definition doxygen.cpp:9282
static void mergeCategories()
Definition doxygen.cpp:8446
static void buildFileList(const Entry *root)
Definition doxygen.cpp:496
static void buildClassList(const Entry *root)
Definition doxygen.cpp:1127
static void findUsedTemplateInstances()
Definition doxygen.cpp:5276
static void computeTooltipTexts()
Definition doxygen.cpp:8900
static void parseFilesSingleThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void buildCompleteMemberLists()
Definition doxygen.cpp:8468
static void combineUsingRelations()
Definition doxygen.cpp:9181
static void checkMarkdownMainfile()
static std::unordered_map< std::string, std::vector< ClassDefMutable * > > g_usingClassMap
Definition doxygen.cpp:2156
static void buildConceptDocList(const Entry *root)
Definition doxygen.cpp:1286
static void parseFilesMultiThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void transferFunctionReferences()
Definition doxygen.cpp:4314
static void buildDefineList()
Definition doxygen.cpp:8803
static void buildInterfaceAndServiceList(const Entry *root)
Definition doxygen.cpp:3582
static void computeMemberRelations()
Definition doxygen.cpp:8411
static void buildListOfUsingDecls(const Entry *root)
Definition doxygen.cpp:1992
static std::multimap< std::string, const Entry * > g_classEntries
Definition doxygen.cpp:186
void printLayout()
Definition layout.cpp:1820
#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:6053
QCString fileToString(const QCString &name, bool filter, bool isSourceCode)
Definition util.cpp:1442
int getPrefixIndex(const QCString &name)
Definition util.cpp:3752

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

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

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

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