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

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

11865{
11866 AUTO_TRACE();
11867
11872}
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 11390 of file doxygen.cpp.

11391{
11395
11396 delete Doxygen::indexList;
11405 Doxygen::mainPage.reset();
11409 Doxygen::globalScope = nullptr;
11411 delete theTranslator;
11412 delete g_outputList;
11413
11418 delete Doxygen::dirLinkedMap;
11419 delete Doxygen::symbolMap;
11420}
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 13040 of file doxygen.cpp.

13041{
13042 AUTO_TRACE();
13043 /**************************************************************************
13044 * Initialize output generators *
13045 **************************************************************************/
13046
13047 /// add extra languages for which we can only produce syntax highlighted code
13049
13050 //// dump all symbols
13051 if (g_dumpSymbolMap)
13052 {
13053 dumpSymbolMap();
13054 exit(0);
13055 }
13056
13057 bool generateHtml = Config_getBool(GENERATE_HTML);
13058 bool generateLatex = Config_getBool(GENERATE_LATEX);
13059 bool generateMan = Config_getBool(GENERATE_MAN);
13060 bool generateRtf = Config_getBool(GENERATE_RTF);
13061 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
13062
13063
13065 if (generateHtml)
13066 {
13070 }
13071 if (generateLatex)
13072 {
13075 }
13076 if (generateDocbook)
13077 {
13080 }
13081 if (generateMan)
13082 {
13083 g_outputList->add<ManGenerator>();
13085 }
13086 if (generateRtf)
13087 {
13088 g_outputList->add<RTFGenerator>();
13090 }
13091 if (Config_getBool(USE_HTAGS))
13092 {
13094 QCString htmldir = Config_getString(HTML_OUTPUT);
13095 if (!Htags::execute(htmldir))
13096 err("USE_HTAGS is YES but htags(1) failed. \n");
13097 else if (!Htags::loadFilemap(htmldir))
13098 err("htags(1) ended normally but failed to load the filemap. \n");
13099 }
13100
13101 /**************************************************************************
13102 * Generate documentation *
13103 **************************************************************************/
13104
13105 g_s.begin("Generating style sheet...\n");
13106 //printf("writing style info\n");
13107 g_outputList->writeStyleInfo(0); // write first part
13108 g_s.end();
13109
13110 bool searchEngine = Config_getBool(SEARCHENGINE);
13111 bool serverBasedSearch = Config_getBool(SERVER_BASED_SEARCH);
13112
13113 g_s.begin("Generating search indices...\n");
13114 if (searchEngine && !serverBasedSearch && generateHtml)
13115 {
13117 }
13118
13119 // generate search indices (need to do this before writing other HTML
13120 // pages as these contain a drop down menu with options depending on
13121 // what categories we find in this function.
13122 if (generateHtml && searchEngine)
13123 {
13124 QCString searchDirName = Config_getString(HTML_OUTPUT)+"/search";
13125 Dir searchDir(searchDirName.str());
13126 if (!searchDir.exists() && !searchDir.mkdir(searchDirName.str()))
13127 {
13128 term("Could not create search results directory '{}' $PWD='{}'\n",
13129 searchDirName,Dir::currentDirPath());
13130 }
13131 HtmlGenerator::writeSearchData(searchDirName);
13132 if (!serverBasedSearch) // client side search index
13133 {
13135 }
13136 }
13137 g_s.end();
13138
13139 // copy static stuff
13140 if (generateHtml)
13141 {
13143 copyLogo(Config_getString(HTML_OUTPUT));
13144 copyIcon(Config_getString(HTML_OUTPUT));
13145 copyExtraFiles(Config_getList(HTML_EXTRA_FILES),"HTML_EXTRA_FILES",Config_getString(HTML_OUTPUT));
13146 }
13147 if (generateLatex)
13148 {
13150 copyLogo(Config_getString(LATEX_OUTPUT));
13151 copyIcon(Config_getString(LATEX_OUTPUT));
13152 copyExtraFiles(Config_getList(LATEX_EXTRA_FILES),"LATEX_EXTRA_FILES",Config_getString(LATEX_OUTPUT));
13153 }
13154 if (generateDocbook)
13155 {
13156 copyLogo(Config_getString(DOCBOOK_OUTPUT));
13157 copyIcon(Config_getString(DOCBOOK_OUTPUT));
13158 }
13159 if (generateRtf)
13160 {
13161 copyLogo(Config_getString(RTF_OUTPUT));
13162 copyIcon(Config_getString(RTF_OUTPUT));
13163 copyExtraFiles(Config_getList(RTF_EXTRA_FILES),"RTF_EXTRA_FILES",Config_getString(RTF_OUTPUT));
13164 }
13165
13167 if (fm.hasFormulas() && generateHtml
13168 && !Config_getBool(USE_MATHJAX))
13169 {
13170 g_s.begin("Generating images for formulas in HTML...\n");
13171 fm.generateImages(Config_getString(HTML_OUTPUT), Config_getEnum(HTML_FORMULA_FORMAT)==HTML_FORMULA_FORMAT_t::svg ?
13173 g_s.end();
13174 }
13175 if (fm.hasFormulas() && generateRtf)
13176 {
13177 g_s.begin("Generating images for formulas in RTF...\n");
13179 g_s.end();
13180 }
13181
13182 if (fm.hasFormulas() && generateDocbook)
13183 {
13184 g_s.begin("Generating images for formulas in Docbook...\n");
13186 g_s.end();
13187 }
13188
13189 g_s.begin("Generating example documentation...\n");
13191 g_s.end();
13192
13193 g_s.begin("Generating file sources...\n");
13195 g_s.end();
13196
13197 g_s.begin("Generating file documentation...\n");
13199 g_s.end();
13200
13201 g_s.begin("Generating page documentation...\n");
13203 g_s.end();
13204
13205 g_s.begin("Generating group documentation...\n");
13207 g_s.end();
13208
13209 g_s.begin("Generating class documentation...\n");
13211 g_s.end();
13212
13213 g_s.begin("Generating concept documentation...\n");
13215 g_s.end();
13216
13217 g_s.begin("Generating module documentation...\n");
13219 g_s.end();
13220
13221 g_s.begin("Generating namespace documentation...\n");
13223 g_s.end();
13224
13225 if (Config_getBool(GENERATE_LEGEND))
13226 {
13227 g_s.begin("Generating graph info page...\n");
13229 g_s.end();
13230 }
13231
13232 g_s.begin("Generating directory documentation...\n");
13234 g_s.end();
13235
13236 if (g_outputList->size()>0)
13237 {
13239 }
13240
13241 g_s.begin("finalizing index lists...\n");
13242 Doxygen::indexList->finalize();
13243 g_s.end();
13244
13245 g_s.begin("writing tag file...\n");
13246 writeTagFile();
13247 g_s.end();
13248
13249 if (Config_getBool(GENERATE_XML))
13250 {
13251 g_s.begin("Generating XML output...\n");
13253 generateXML();
13255 g_s.end();
13256 }
13257 if (Config_getBool(GENERATE_SQLITE3))
13258 {
13259 g_s.begin("Generating SQLITE3 output...\n");
13261 g_s.end();
13262 }
13263
13264 if (Config_getBool(GENERATE_AUTOGEN_DEF))
13265 {
13266 g_s.begin("Generating AutoGen DEF output...\n");
13267 generateDEF();
13268 g_s.end();
13269 }
13270 if (Config_getBool(GENERATE_PERLMOD))
13271 {
13272 g_s.begin("Generating Perl module output...\n");
13274 g_s.end();
13275 }
13276 if (generateHtml && searchEngine && serverBasedSearch)
13277 {
13278 g_s.begin("Generating search index\n");
13279 if (Doxygen::searchIndex.kind()==SearchIndexIntf::Internal) // write own search index
13280 {
13282 Doxygen::searchIndex.write(Config_getString(HTML_OUTPUT)+"/search/search.idx");
13283 }
13284 else // write data for external search index
13285 {
13287 QCString searchDataFile = Config_getString(SEARCHDATA_FILE);
13288 if (searchDataFile.isEmpty())
13289 {
13290 searchDataFile="searchdata.xml";
13291 }
13292 if (!Portable::isAbsolutePath(searchDataFile.data()))
13293 {
13294 searchDataFile.prepend(Config_getString(OUTPUT_DIRECTORY)+"/");
13295 }
13296 Doxygen::searchIndex.write(searchDataFile);
13297 }
13298 g_s.end();
13299 }
13300
13301 if (generateRtf)
13302 {
13303 g_s.begin("Combining RTF output...\n");
13304 if (!RTFGenerator::preProcessFileInplace(Config_getString(RTF_OUTPUT),"refman.rtf"))
13305 {
13306 err("An error occurred during post-processing the RTF files!\n");
13307 }
13308 g_s.end();
13309 }
13310
13311 g_s.begin("Running plantuml with JAVA...\n");
13313 g_s.end();
13314
13315 if (Config_getBool(HAVE_DOT))
13316 {
13317 g_s.begin("Running dot...\n");
13319 g_s.end();
13320 }
13321
13322 if (generateHtml &&
13323 Config_getBool(GENERATE_HTMLHELP) &&
13324 !Config_getString(HHC_LOCATION).isEmpty())
13325 {
13326 g_s.begin("Running html help compiler...\n");
13328 g_s.end();
13329 }
13330
13331 if ( generateHtml &&
13332 Config_getBool(GENERATE_QHP) &&
13333 !Config_getString(QHG_LOCATION).isEmpty())
13334 {
13335 g_s.begin("Running qhelpgenerator...\n");
13337 g_s.end();
13338 }
13339
13340 g_outputList->cleanup();
13341
13342 msg("type lookup cache used {}/{} hits={} misses={}\n",
13344 Doxygen::typeLookupCache->capacity(),
13346 Doxygen::typeLookupCache->misses());
13347 msg("symbol lookup cache used {}/{} hits={} misses={}\n",
13349 Doxygen::symbolLookupCache->capacity(),
13351 Doxygen::symbolLookupCache->misses());
13352 int typeCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::typeLookupCache->misses()*2/3)); // part of the cache is flushed, hence the 2/3 correction factor
13353 int symbolCacheParam = computeIdealCacheParam(static_cast<size_t>(Doxygen::symbolLookupCache->misses()));
13354 int cacheParam = std::max(typeCacheParam,symbolCacheParam);
13355 if (cacheParam>Config_getInt(LOOKUP_CACHE_SIZE))
13356 {
13357 msg("Note: based on cache misses the ideal setting for LOOKUP_CACHE_SIZE is {} at the cost of higher memory usage.\n",cacheParam);
13358 }
13359
13361 {
13362
13363 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
13364 if (numThreads<1) numThreads=1;
13365 msg("Total elapsed time: {:.6f} seconds\n(of which an average of {:.6f} seconds per thread waiting for external tools to finish)\n",
13366 (static_cast<double>(Debug::elapsedTime())),
13367 Portable::getSysElapsedTime()/static_cast<double>(numThreads)
13368 );
13369 g_s.print();
13370
13372 msg("finished...\n");
13374 }
13375 else
13376 {
13377 msg("finished...\n");
13378 }
13379
13380
13381 /**************************************************************************
13382 * Start cleaning up *
13383 **************************************************************************/
13384
13386
13388 Dir thisDir;
13389 thisDir.remove(Doxygen::filterDBFileName.str());
13391 exitTracing();
13393 delete Doxygen::clangUsrMap;
13395
13396 //dumpDocNodeSizes();
13397}
@ 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:1160
static void writeSearchPage()
Definition htmlgen.cpp:3123
static void writeTabData()
Additional initialization after indices have been created.
Definition htmlgen.cpp:1311
static void writeSearchData(const QCString &dir)
Definition htmlgen.cpp:1320
static void writeExternalSearchPage()
Definition htmlgen.cpp:3222
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:407
const std::string & str() const
Definition qcstring.h:537
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()
static void generateExampleDocs()
Definition doxygen.cpp:9958
static void dumpSymbolMap()
static void generateFileDocs()
Definition doxygen.cpp:8667
static void copyIcon(const QCString &outputOption)
static void generatePageDocs()
Definition doxygen.cpp:9873
static void generateFileSources()
Definition doxygen.cpp:8501
static void copyLogo(const QCString &outputOption)
static void generateClassDocs()
Definition doxygen.cpp:9102
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:9128
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:514
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 11321 of file doxygen.cpp.

11322{
11323 initResources();
11324 QCString lang = Portable::getenv("LC_ALL");
11325 if (!lang.isEmpty()) Portable::setenv("LANG",lang);
11326 std::setlocale(LC_ALL,"");
11327 std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
11328 std::setlocale(LC_NUMERIC,"C");
11329
11331
11355
11356 // register any additional parsers here...
11357
11359
11360#if USE_LIBCLANG
11362#endif
11371 Doxygen::pageLinkedMap = new PageLinkedMap; // all doc pages
11372 Doxygen::exampleLinkedMap = new PageLinkedMap; // all examples
11373 //Doxygen::tagDestinationDict.setAutoDelete(TRUE);
11375
11376 // initialization of these globals depends on
11377 // configuration switches so we need to postpone these
11378 Doxygen::globalScope = nullptr;
11387
11388}
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:303
QCString getenv(const QCString &variable)
Definition portable.cpp:338
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 12365 of file doxygen.cpp.

12366{
12367 AUTO_TRACE();
12368 std::atexit(exitDoxygen);
12369
12370 Portable::correctPath(Config_getList(EXTERNAL_TOOL_PATH));
12371
12372#if USE_LIBCLANG
12373 Doxygen::clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
12374#endif
12375
12376 // we would like to show the versionString earlier, but we first have to handle the configuration file
12377 // to know the value of the QUIET setting.
12378 QCString versionString = getFullVersion();
12379 msg("Doxygen version used: {}\n",versionString);
12380
12382
12383 /**************************************************************************
12384 * Make sure the output directory exists
12385 **************************************************************************/
12386 QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
12387 if (!g_singleComment)
12388 {
12389 if (outputDirectory.isEmpty())
12390 {
12391 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,Dir::currentDirPath().c_str());
12392 }
12393 else
12394 {
12395 Dir dir(outputDirectory.str());
12396 if (!dir.exists())
12397 {
12398 dir.setPath(Dir::currentDirPath());
12399 if (!dir.mkdir(outputDirectory.str()))
12400 {
12401 term("tag OUTPUT_DIRECTORY: Output directory '{}' does not "
12402 "exist and cannot be created\n",outputDirectory);
12403 }
12404 else
12405 {
12406 msg("Notice: Output directory '{}' does not exist. "
12407 "I have created it for you.\n", outputDirectory);
12408 }
12409 dir.setPath(outputDirectory.str());
12410 }
12411 outputDirectory = Config_updateString(OUTPUT_DIRECTORY,dir.absPath().c_str());
12412 }
12413 }
12414 AUTO_TRACE_ADD("outputDirectory={}",outputDirectory);
12415
12416 /**************************************************************************
12417 * Initialize global lists and dictionaries
12418 **************************************************************************/
12419
12420 // also scale lookup cache with SYMBOL_CACHE_SIZE
12421 int cacheSize = Config_getInt(LOOKUP_CACHE_SIZE);
12422 if (cacheSize<0) cacheSize=0;
12423 if (cacheSize>9) cacheSize=9;
12424 uint32_t lookupSize = 65536 << cacheSize;
12427
12428#ifdef HAS_SIGNALS
12429 signal(SIGINT, stopDoxygen);
12430#endif
12431
12432 uint32_t pid = Portable::pid();
12433 Doxygen::filterDBFileName.sprintf("doxygen_filterdb_%d.tmp",pid);
12434 Doxygen::filterDBFileName.prepend(outputDirectory+"/");
12435
12436 /**************************************************************************
12437 * Check/create output directories *
12438 **************************************************************************/
12439
12440 bool generateHtml = Config_getBool(GENERATE_HTML);
12441 bool generateDocbook = Config_getBool(GENERATE_DOCBOOK);
12442 bool generateXml = Config_getBool(GENERATE_XML);
12443 bool generateLatex = Config_getBool(GENERATE_LATEX);
12444 bool generateRtf = Config_getBool(GENERATE_RTF);
12445 bool generateMan = Config_getBool(GENERATE_MAN);
12446 bool generateSql = Config_getBool(GENERATE_SQLITE3);
12447 QCString htmlOutput;
12448 QCString docbookOutput;
12449 QCString xmlOutput;
12450 QCString latexOutput;
12451 QCString rtfOutput;
12452 QCString manOutput;
12453 QCString sqlOutput;
12454
12455 if (!g_singleComment)
12456 {
12457 if (generateHtml)
12458 {
12459 htmlOutput = createOutputDirectory(outputDirectory,Config_getString(HTML_OUTPUT),"/html");
12460 Config_updateString(HTML_OUTPUT,htmlOutput);
12461
12462 QCString sitemapUrl = Config_getString(SITEMAP_URL);
12463 bool generateSitemap = !sitemapUrl.isEmpty();
12464 if (generateSitemap && !sitemapUrl.endsWith("/"))
12465 {
12466 Config_updateString(SITEMAP_URL,sitemapUrl+"/");
12467 }
12468
12469 // add HTML indexers that are enabled
12470 bool generateHtmlHelp = Config_getBool(GENERATE_HTMLHELP);
12471 bool generateEclipseHelp = Config_getBool(GENERATE_ECLIPSEHELP);
12472 bool generateQhp = Config_getBool(GENERATE_QHP);
12473 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
12474 bool generateDocSet = Config_getBool(GENERATE_DOCSET);
12475 if (generateEclipseHelp) Doxygen::indexList->addIndex<EclipseHelp>();
12476 if (generateHtmlHelp) Doxygen::indexList->addIndex<HtmlHelp>();
12477 if (generateQhp) Doxygen::indexList->addIndex<Qhp>();
12478 if (generateSitemap) Doxygen::indexList->addIndex<Sitemap>();
12479 if (generateTreeView) Doxygen::indexList->addIndex<FTVHelp>(TRUE);
12480 if (generateDocSet) Doxygen::indexList->addIndex<DocSets>();
12481 Doxygen::indexList->addIndex<Crawlmap>();
12482 Doxygen::indexList->initialize();
12483 }
12484
12485 if (generateDocbook)
12486 {
12487 docbookOutput = createOutputDirectory(outputDirectory,Config_getString(DOCBOOK_OUTPUT),"/docbook");
12488 Config_updateString(DOCBOOK_OUTPUT,docbookOutput);
12489 }
12490
12491 if (generateXml)
12492 {
12493 xmlOutput = createOutputDirectory(outputDirectory,Config_getString(XML_OUTPUT),"/xml");
12494 Config_updateString(XML_OUTPUT,xmlOutput);
12495 }
12496
12497 if (generateLatex)
12498 {
12499 latexOutput = createOutputDirectory(outputDirectory,Config_getString(LATEX_OUTPUT), "/latex");
12500 Config_updateString(LATEX_OUTPUT,latexOutput);
12501 }
12502
12503 if (generateRtf)
12504 {
12505 rtfOutput = createOutputDirectory(outputDirectory,Config_getString(RTF_OUTPUT),"/rtf");
12506 Config_updateString(RTF_OUTPUT,rtfOutput);
12507 }
12508
12509 if (generateMan)
12510 {
12511 manOutput = createOutputDirectory(outputDirectory,Config_getString(MAN_OUTPUT),"/man");
12512 Config_updateString(MAN_OUTPUT,manOutput);
12513 }
12514
12515 if (generateSql)
12516 {
12517 sqlOutput = createOutputDirectory(outputDirectory,Config_getString(SQLITE3_OUTPUT),"/sqlite3");
12518 Config_updateString(SQLITE3_OUTPUT,sqlOutput);
12519 }
12520 }
12521
12522 if (Config_getBool(HAVE_DOT))
12523 {
12524 QCString curFontPath = Config_getString(DOT_FONTPATH);
12525 if (curFontPath.isEmpty())
12526 {
12527 Portable::getenv("DOTFONTPATH");
12528 QCString newFontPath = ".";
12529 if (!curFontPath.isEmpty())
12530 {
12531 newFontPath+=Portable::pathListSeparator();
12532 newFontPath+=curFontPath;
12533 }
12534 Portable::setenv("DOTFONTPATH",qPrint(newFontPath));
12535 }
12536 else
12537 {
12538 Portable::setenv("DOTFONTPATH",qPrint(curFontPath));
12539 }
12540 }
12541
12542 /**************************************************************************
12543 * Handle layout file *
12544 **************************************************************************/
12545
12547 QCString layoutFileName = Config_getString(LAYOUT_FILE);
12548 bool defaultLayoutUsed = FALSE;
12549 if (layoutFileName.isEmpty())
12550 {
12551 layoutFileName = Config_updateString(LAYOUT_FILE,"DoxygenLayout.xml");
12552 defaultLayoutUsed = TRUE;
12553 }
12554 AUTO_TRACE_ADD("defaultLayoutUsed={}, layoutFileName={}",defaultLayoutUsed,layoutFileName);
12555
12556 FileInfo fi(layoutFileName.str());
12557 if (fi.exists())
12558 {
12559 msg("Parsing layout file {}...\n",layoutFileName);
12560 LayoutDocManager::instance().parse(layoutFileName);
12561 }
12562 else if (!defaultLayoutUsed)
12563 {
12564 warn_uncond("failed to open layout file '{}' for reading! Using default settings.\n",layoutFileName);
12565 }
12566 printLayout();
12567
12568 /**************************************************************************
12569 * Read and preprocess input *
12570 **************************************************************************/
12571
12572 // prevent search in the output directories
12573 StringVector exclPatterns = Config_getList(EXCLUDE_PATTERNS);
12574 if (generateHtml) exclPatterns.push_back(htmlOutput.str());
12575 if (generateDocbook) exclPatterns.push_back(docbookOutput.str());
12576 if (generateXml) exclPatterns.push_back(xmlOutput.str());
12577 if (generateLatex) exclPatterns.push_back(latexOutput.str());
12578 if (generateRtf) exclPatterns.push_back(rtfOutput.str());
12579 if (generateMan) exclPatterns.push_back(manOutput.str());
12580 Config_updateList(EXCLUDE_PATTERNS,exclPatterns);
12581
12582 if (!g_singleComment)
12583 {
12585
12587 }
12588
12589 // Notice: the order of the function calls below is very important!
12590
12591 if (generateHtml && !Config_getBool(USE_MATHJAX))
12592 {
12594 }
12595 if (generateRtf)
12596 {
12598 }
12599 if (generateDocbook)
12600 {
12602 }
12603
12605
12606 /**************************************************************************
12607 * Handle Tag Files *
12608 **************************************************************************/
12609
12610 std::shared_ptr<Entry> root = std::make_shared<Entry>();
12611
12612 if (!g_singleComment)
12613 {
12614 msg("Reading and parsing tag files\n");
12615 const StringVector &tagFileList = Config_getList(TAGFILES);
12616 for (const auto &s : tagFileList)
12617 {
12618 readTagFile(root,s.c_str());
12619 }
12620 }
12621
12622 /**************************************************************************
12623 * Parse source files *
12624 **************************************************************************/
12625
12626 addSTLSupport(root);
12627
12628 g_s.begin("Parsing files\n");
12629 if (g_singleComment)
12630 {
12631 //printf("Parsing comment %s\n",qPrint(g_commentFileName));
12632 if (g_commentFileName=="-")
12633 {
12634 std::string text = fileToString(g_commentFileName).str();
12635 addTerminalCharIfMissing(text,'\n');
12636 generateHtmlForComment("stdin.md",text);
12637 }
12638 else if (FileInfo(g_commentFileName.str()).isFile())
12639 {
12640 std::string text;
12642 addTerminalCharIfMissing(text,'\n');
12644 }
12645 else
12646 {
12647 }
12649 exit(0);
12650 }
12651 else
12652 {
12653 if (Config_getInt(NUM_PROC_THREADS)==1)
12654 {
12656 }
12657 else
12658 {
12660 }
12661 }
12662 g_s.end();
12663
12664 /**************************************************************************
12665 * Gather information *
12666 **************************************************************************/
12667
12668 g_s.begin("Building macro definition list...\n");
12670 g_s.end();
12671
12672 g_s.begin("Building group list...\n");
12673 buildGroupList(root.get());
12674 organizeSubGroups(root.get());
12675 g_s.end();
12676
12677 g_s.begin("Building directory list...\n");
12679 findDirDocumentation(root.get());
12680 g_s.end();
12681
12682 g_s.begin("Building namespace list...\n");
12683 buildNamespaceList(root.get());
12684 findUsingDirectives(root.get());
12685 g_s.end();
12686
12687 g_s.begin("Building file list...\n");
12688 buildFileList(root.get());
12689 g_s.end();
12690
12691 g_s.begin("Building class list...\n");
12692 buildClassList(root.get());
12693 g_s.end();
12694
12695 g_s.begin("Building concept list...\n");
12696 buildConceptList(root.get());
12697 g_s.end();
12698
12699 // build list of using declarations here (global list)
12700 buildListOfUsingDecls(root.get());
12701 g_s.end();
12702
12703 g_s.begin("Computing nesting relations for classes...\n");
12705 g_s.end();
12706 // 1.8.2-20121111: no longer add nested classes to the group as well
12707 //distributeClassGroupRelations();
12708
12709 // calling buildClassList may result in cached relations that
12710 // become invalid after resolveClassNestingRelations(), that's why
12711 // we need to clear the cache here
12712 Doxygen::typeLookupCache->clear();
12713 // we don't need the list of using declaration anymore
12714 g_usingDeclarations.clear();
12715
12716 g_s.begin("Associating documentation with classes...\n");
12717 buildClassDocList(root.get());
12718 g_s.end();
12719
12720 g_s.begin("Associating documentation with concepts...\n");
12721 buildConceptDocList(root.get());
12723 g_s.end();
12724
12725 g_s.begin("Associating documentation with modules...\n");
12726 findModuleDocumentation(root.get());
12727 g_s.end();
12728
12729 g_s.begin("Building example list...\n");
12730 buildExampleList(root.get());
12731 g_s.end();
12732
12733 g_s.begin("Searching for enumerations...\n");
12734 findEnums(root.get());
12735 g_s.end();
12736
12737 // Since buildVarList calls isVarWithConstructor
12738 // and this calls getResolvedClass we need to process
12739 // typedefs first so the relations between classes via typedefs
12740 // are properly resolved. See bug 536385 for an example.
12741 g_s.begin("Searching for documented typedefs...\n");
12742 buildTypedefList(root.get());
12743 g_s.end();
12744
12745 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
12746 {
12747 g_s.begin("Searching for documented sequences...\n");
12748 buildSequenceList(root.get());
12749 g_s.end();
12750
12751 g_s.begin("Searching for documented dictionaries...\n");
12752 buildDictionaryList(root.get());
12753 g_s.end();
12754 }
12755
12756 g_s.begin("Searching for members imported via using declarations...\n");
12757 // this should be after buildTypedefList in order to properly import
12758 // used typedefs
12759 findUsingDeclarations(root.get(),TRUE); // do for python packages first
12760 findUsingDeclarations(root.get(),FALSE); // then the rest
12761 g_s.end();
12762
12763 g_s.begin("Searching for included using directives...\n");
12765 g_s.end();
12766
12767 g_s.begin("Searching for documented variables...\n");
12768 buildVarList(root.get());
12769 g_s.end();
12770
12771 g_s.begin("Building interface member list...\n");
12772 buildInterfaceAndServiceList(root.get()); // UNO IDL
12773
12774 g_s.begin("Building member list...\n"); // using class info only !
12775 buildFunctionList(root.get());
12776 g_s.end();
12777
12778 g_s.begin("Searching for friends...\n");
12779 findFriends();
12780 g_s.end();
12781
12782 g_s.begin("Searching for documented defines...\n");
12783 findDefineDocumentation(root.get());
12784 g_s.end();
12785
12786 g_s.begin("Computing class inheritance relations...\n");
12787 findClassEntries(root.get());
12789 g_s.end();
12790
12791 g_s.begin("Computing class usage relations...\n");
12793 g_s.end();
12794
12795 if (Config_getBool(INLINE_SIMPLE_STRUCTS))
12796 {
12797 g_s.begin("Searching for tag less structs...\n");
12799 g_s.end();
12800 }
12801
12802 g_s.begin("Flushing cached template relations that have become invalid...\n");
12804 g_s.end();
12805
12806 g_s.begin("Warn for undocumented namespaces...\n");
12808 g_s.end();
12809
12810 g_s.begin("Computing class relations...\n");
12813 if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
12814 {
12816 }
12818 g_classEntries.clear();
12819 g_s.end();
12820
12821 g_s.begin("Add enum values to enums...\n");
12822 addEnumValuesToEnums(root.get());
12823 findEnumDocumentation(root.get());
12824 g_s.end();
12825
12826 g_s.begin("Searching for member function documentation...\n");
12827 findObjCMethodDefinitions(root.get());
12828 findMemberDocumentation(root.get()); // may introduce new members !
12829 findUsingDeclImports(root.get()); // may introduce new members !
12830 g_usingClassMap.clear();
12834 g_s.end();
12835
12836 // moved to after finding and copying documentation,
12837 // as this introduces new members see bug 722654
12838 g_s.begin("Creating members for template instances...\n");
12840 g_s.end();
12841
12842 g_s.begin("Building page list...\n");
12843 buildPageList(root.get());
12844 g_s.end();
12845
12846 g_s.begin("Search for main page...\n");
12847 findMainPage(root.get());
12848 findMainPageTagFiles(root.get());
12849 g_s.end();
12850
12851 g_s.begin("Computing page relations...\n");
12852 computePageRelations(root.get());
12854 g_s.end();
12855
12856 g_s.begin("Determining the scope of groups...\n");
12857 findGroupScope(root.get());
12858 g_s.end();
12859
12860 g_s.begin("Computing module relations...\n");
12861 auto &mm = ModuleManager::instance();
12862 mm.resolvePartitions();
12863 mm.resolveImports();
12864 mm.collectExportedSymbols();
12865 g_s.end();
12866
12867 auto memberNameComp = [](const MemberNameLinkedMap::Ptr &n1,const MemberNameLinkedMap::Ptr &n2)
12868 {
12869 return qstricmp_sort(n1->memberName().data()+getPrefixIndex(n1->memberName()),
12870 n2->memberName().data()+getPrefixIndex(n2->memberName())
12871 )<0;
12872 };
12873
12874 auto classComp = [](const ClassLinkedMap::Ptr &c1,const ClassLinkedMap::Ptr &c2)
12875 {
12876 if (Config_getBool(SORT_BY_SCOPE_NAME))
12877 {
12878 return qstricmp_sort(c1->name(), c2->name())<0;
12879 }
12880 else
12881 {
12882 int i = qstricmp_sort(c1->className(), c2->className());
12883 return i==0 ? qstricmp_sort(c1->name(), c2->name())<0 : i<0;
12884 }
12885 };
12886
12887 auto namespaceComp = [](const NamespaceLinkedMap::Ptr &n1,const NamespaceLinkedMap::Ptr &n2)
12888 {
12889 return qstricmp_sort(n1->name(),n2->name())<0;
12890 };
12891
12892 auto conceptComp = [](const ConceptLinkedMap::Ptr &c1,const ConceptLinkedMap::Ptr &c2)
12893 {
12894 return qstricmp_sort(c1->name(),c2->name())<0;
12895 };
12896
12897 g_s.begin("Sorting lists...\n");
12898 std::stable_sort(Doxygen::memberNameLinkedMap->begin(),
12900 memberNameComp);
12901 std::stable_sort(Doxygen::functionNameLinkedMap->begin(),
12903 memberNameComp);
12904 std::stable_sort(Doxygen::hiddenClassLinkedMap->begin(),
12906 classComp);
12907 std::stable_sort(Doxygen::classLinkedMap->begin(),
12909 classComp);
12910 std::stable_sort(Doxygen::conceptLinkedMap->begin(),
12912 conceptComp);
12913 std::stable_sort(Doxygen::namespaceLinkedMap->begin(),
12915 namespaceComp);
12916 g_s.end();
12917
12918 g_s.begin("Determining which enums are documented\n");
12920 g_s.end();
12921
12922 g_s.begin("Computing member relations...\n");
12925 g_s.end();
12926
12927 g_s.begin("Building full member lists recursively...\n");
12929 g_s.end();
12930
12931 g_s.begin("Adding members to member groups.\n");
12933 g_s.end();
12934
12935 if (Config_getBool(DISTRIBUTE_GROUP_DOC))
12936 {
12937 g_s.begin("Distributing member group documentation.\n");
12939 g_s.end();
12940 }
12941
12942 g_s.begin("Computing member references...\n");
12944 g_s.end();
12945
12946 if (Config_getBool(INHERIT_DOCS))
12947 {
12948 g_s.begin("Inheriting documentation...\n");
12950 g_s.end();
12951 }
12952
12953
12954 // compute the shortest possible names of all files
12955 // without losing the uniqueness of the file names.
12956 g_s.begin("Generating disk names...\n");
12958 g_s.end();
12959
12960 g_s.begin("Adding source references...\n");
12962 g_s.end();
12963
12964 g_s.begin("Adding xrefitems...\n");
12967 g_s.end();
12968
12969 g_s.begin("Sorting member lists...\n");
12971 g_s.end();
12972
12973 g_s.begin("Setting anonymous enum type...\n");
12975 g_s.end();
12976
12977 g_s.begin("Computing dependencies between directories...\n");
12979 g_s.end();
12980
12981 g_s.begin("Generating citations page...\n");
12983 g_s.end();
12984
12985 g_s.begin("Counting members...\n");
12986 countMembers();
12987 g_s.end();
12988
12989 g_s.begin("Counting data structures...\n");
12991 g_s.end();
12992
12993 g_s.begin("Resolving user defined references...\n");
12995 g_s.end();
12996
12997 g_s.begin("Finding anchors and sections in the documentation...\n");
12999 g_s.end();
13000
13001 g_s.begin("Transferring function references...\n");
13003 g_s.end();
13004
13005 g_s.begin("Combining using relations...\n");
13007 g_s.end();
13008
13010 g_s.begin("Adding members to index pages...\n");
13012 addToIndices();
13013 g_s.end();
13014
13015 g_s.begin("Correcting members for VHDL...\n");
13017 g_s.end();
13018
13019 g_s.begin("Computing tooltip texts...\n");
13021 g_s.end();
13022
13023 if (Config_getBool(SORT_GROUP_NAMES))
13024 {
13025 std::stable_sort(Doxygen::groupLinkedMap->begin(),
13027 [](const auto &g1,const auto &g2)
13028 { return g1->groupTitle() < g2->groupTitle(); });
13029
13030 for (const auto &gd : *Doxygen::groupLinkedMap)
13031 {
13032 gd->sortSubGroups();
13033 }
13034 }
13035
13036 printNavTree(root.get(),0);
13038}
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:509
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:5245
void printNavTree(Entry *root, int indent)
Definition doxygen.cpp:9919
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:9344
static void computeTemplateClassRelations()
Definition doxygen.cpp:5339
void printSectionsTree()
Definition doxygen.cpp:9942
static void generateXRefPages()
Definition doxygen.cpp:5511
static void findUsingDeclImports(const Entry *root)
Definition doxygen.cpp:2158
static void findDirDocumentation(const Entry *root)
Definition doxygen.cpp:9583
static void warnUndocumentedNamespaces()
Definition doxygen.cpp:5294
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:5208
static void vhdlCorrectMemberProperties()
Definition doxygen.cpp:8302
static void stopDoxygen(int)
static void computeMemberReferences()
Definition doxygen.cpp:5408
static void transferRelatedFunctionDocumentation()
Definition doxygen.cpp:4364
static void addMembersToMemberGroup()
Definition doxygen.cpp:9209
static void findMainPageTagFiles(Entry *root)
Definition doxygen.cpp:9743
static void distributeConceptGroups()
Definition doxygen.cpp:1298
static void transferFunctionDocumentation()
Definition doxygen.cpp:4283
static void setAnonymousEnumType()
Definition doxygen.cpp:8949
static void sortMemberLists()
Definition doxygen.cpp:8854
static void createTemplateInstanceMembers()
Definition doxygen.cpp:8430
void transferStaticInstanceInitializers()
Definition doxygen.cpp:4413
static void findObjCMethodDefinitions(const Entry *root)
Definition doxygen.cpp:7445
static void buildTypedefList(const Entry *root)
Definition doxygen.cpp:3354
static void findGroupScope(const Entry *root)
Definition doxygen.cpp:440
static void findDefineDocumentation(Entry *root)
Definition doxygen.cpp:9496
static void findMemberDocumentation(const Entry *root)
Definition doxygen.cpp:7415
static void distributeMemberGroupDocumentation()
Definition doxygen.cpp:9247
static void addEnumValuesToEnums(const Entry *root)
Definition doxygen.cpp:7648
static void resolveUserReferences()
Definition doxygen.cpp:9805
static void buildVarList(const Entry *root)
Definition doxygen.cpp:3490
static void buildSequenceList(const Entry *root)
Definition doxygen.cpp:3453
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:8963
static void organizeSubGroups(const Entry *root)
Definition doxygen.cpp:484
void searchInputFiles()
static void findFriends()
Definition doxygen.cpp:4186
static void findEnums(const Entry *root)
Definition doxygen.cpp:7473
static void addListReferences()
Definition doxygen.cpp:5442
static void exitDoxygen() noexcept
static void addMembersToIndex()
Definition doxygen.cpp:8092
static void findMainPage(Entry *root)
Definition doxygen.cpp:9673
static void findUsingDirectives(const Entry *root)
Definition doxygen.cpp:1850
static void addSourceReferences()
Definition doxygen.cpp:8727
static void buildExampleList(Entry *root)
Definition doxygen.cpp:9890
static void inheritDocumentation()
Definition doxygen.cpp:9149
static void flushUnresolvedRelations()
Definition doxygen.cpp:9398
static QCString g_commentFileName
Definition doxygen.cpp:192
static void findDocumentedEnumValues()
Definition doxygen.cpp:8084
static void findTagLessClasses()
Definition doxygen.cpp:1646
static void generateDiskNames()
static void addToIndices()
Definition doxygen.cpp:8134
static void computeClassRelations()
Definition doxygen.cpp:5314
static void buildFunctionList(const Entry *root)
Definition doxygen.cpp:3880
static void checkPageRelations()
Definition doxygen.cpp:9785
static void findModuleDocumentation(const Entry *root)
Definition doxygen.cpp:1266
static void findEnumDocumentation(const Entry *root)
Definition doxygen.cpp:7972
static void computePageRelations(Entry *root)
Definition doxygen.cpp:9755
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:3471
static void buildClassDocList(const Entry *root)
Definition doxygen.cpp:1137
static void buildPageList(Entry *root)
Definition doxygen.cpp:9646
static void computeVerifiedDotPath()
static bool g_singleComment
Definition doxygen.cpp:193
static void findSectionsInDocumentation()
Definition doxygen.cpp:9285
static void mergeCategories()
Definition doxygen.cpp:8449
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:5278
static void computeTooltipTexts()
Definition doxygen.cpp:8903
static void parseFilesSingleThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void buildCompleteMemberLists()
Definition doxygen.cpp:8471
static void combineUsingRelations()
Definition doxygen.cpp:9184
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:4316
static void buildDefineList()
Definition doxygen.cpp:8806
static void buildInterfaceAndServiceList(const Entry *root)
Definition doxygen.cpp:3584
static void computeMemberRelations()
Definition doxygen.cpp:8414
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:533
QCString pathListSeparator()
Definition portable.cpp:400
uint32_t pid()
Definition portable.cpp:265
int qstricmp_sort(const char *str1, const char *str2)
Definition qcstring.h:86
const char * qPrint(const char *s)
Definition qcstring.h:672
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 11434 of file doxygen.cpp.

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

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