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

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

References AUTO_TRACE, Config_getBool, Config_getEnum, Config_getInt, Config_getList, Config_getString, createNamespaceDef(), data, QCString::data(), Doxygen::diaFileNameLinkedMap, Doxygen::dotFileNameLinkedMap, err, Doxygen::exampleNameLinkedMap, Doxygen::expandAsDefinedSet, QCString::find(), get(), Doxygen::globalNamespaceDef, Doxygen::globalScope, Doxygen::htmlFileExtension, i, 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(), s, setTranslator(), Doxygen::spaces, QCString::stripWhiteSpace(), term, toNamespaceDefMutable(), and updateLanguageMapping().

Referenced by main().

◆ checkConfiguration()

void checkConfiguration ( )

check and resolve config options

Definition at line 11862 of file doxygen.cpp.

11863{
11864 AUTO_TRACE();
11865
11870}
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 11388 of file doxygen.cpp.

11389{
11393
11394 delete Doxygen::indexList;
11403 Doxygen::mainPage.reset();
11407 Doxygen::globalScope = nullptr;
11409 delete theTranslator;
11410 delete g_outputList;
11411
11416 delete Doxygen::dirLinkedMap;
11417 delete Doxygen::symbolMap;
11418}
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 13038 of file doxygen.cpp.

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

11320{
11321 initResources();
11322 QCString lang = Portable::getenv("LC_ALL");
11323 if (!lang.isEmpty()) Portable::setenv("LANG",lang);
11324 std::setlocale(LC_ALL,"");
11325 std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
11326 std::setlocale(LC_NUMERIC,"C");
11327
11329
11353
11354 // register any additional parsers here...
11355
11357
11358#if USE_LIBCLANG
11360#endif
11369 Doxygen::pageLinkedMap = new PageLinkedMap; // all doc pages
11370 Doxygen::exampleLinkedMap = new PageLinkedMap; // all examples
11371 //Doxygen::tagDestinationDict.setAutoDelete(TRUE);
11373
11374 // initialization of these globals depends on
11375 // configuration switches so we need to postpone these
11376 Doxygen::globalScope = nullptr;
11385
11386}
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:5646

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

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

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, i, 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(), s, 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 11432 of file doxygen.cpp.

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

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

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

Referenced by searchInputFiles().