Doxygen
Loading...
Searching...
No Matches
doxygen.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2015 by Dimitri van Heesch.
4 *
5 * Permission to use, copy, modify, and distribute this software and its
6 * documentation under the terms of the GNU General Public License is hereby
7 * granted. No representations are made about the suitability of this software
8 * for any purpose. It is provided "as is" without express or implied warranty.
9 * See the GNU General Public License for more details.
10 *
11 * Documents produced by Doxygen are derivative works derived from the
12 * input used in their production; they are not affected by this license.
13 *
14 */
15
16#include <cstdio>
17#include <cstdlib>
18#include <cerrno>
19#include <sys/stat.h>
20
21#include <algorithm>
22#include <unordered_map>
23#include <memory>
24#include <cinttypes>
25#include <chrono>
26#include <clocale>
27#include <locale>
28
29#include "version.h"
30#include "doxygen.h"
31#include "scanner.h"
32#include "entry.h"
33#include "index.h"
34#include "indexlist.h"
35#include "message.h"
36#include "config.h"
37#include "util.h"
38#include "pre.h"
39#include "tagreader.h"
40#include "dot.h"
41#include "msc.h"
42#include "docparser.h"
43#include "dirdef.h"
44#include "outputlist.h"
45#include "declinfo.h"
46#include "htmlgen.h"
47#include "latexgen.h"
48#include "mangen.h"
49#include "language.h"
50#include "debug.h"
51#include "htmlhelp.h"
52#include "qhp.h"
53#include "sitemap.h"
54#include "ftvhelp.h"
55#include "defargs.h"
56#include "rtfgen.h"
57#include "sqlite3gen.h"
58#include "xmlgen.h"
59#include "docbookgen.h"
60#include "defgen.h"
61#include "perlmodgen.h"
62#include "reflist.h"
63#include "pagedef.h"
64#include "commentcnv.h"
65#include "cmdmapper.h"
66#include "searchindex_js.h"
67#include "parserintf.h"
68#include "htags.h"
69#include "pycode.h"
70#include "pyscanner.h"
71#include "fortrancode.h"
72#include "fortranscanner.h"
73#include "xmlcode.h"
74#include "sqlcode.h"
75#include "lexcode.h"
76#include "lexscanner.h"
77#include "code.h"
78#include "portable.h"
79#include "vhdljjparser.h"
80#include "vhdldocgen.h"
81#include "vhdlcode.h"
82#include "eclipsehelp.h"
83#include "cite.h"
84#include "markdown.h"
85#include "arguments.h"
86#include "memberlist.h"
87#include "layout.h"
88#include "groupdef.h"
89#include "classlist.h"
90#include "namespacedef.h"
91#include "filename.h"
92#include "membername.h"
93#include "membergroup.h"
94#include "docsets.h"
95#include "formula.h"
96#include "settings.h"
97#include "fileparser.h"
98#include "emoji.h"
99#include "plantuml.h"
100#include "stlsupport.h"
101#include "threadpool.h"
102#include "clangparser.h"
103#include "symbolresolver.h"
104#include "regex.h"
105#include "aliases.h"
106#include "fileinfo.h"
107#include "dir.h"
108#include "conceptdef.h"
109#include "trace.h"
110#include "moduledef.h"
111#include "stringutil.h"
112#include "singlecomment.h"
113
114#include <sqlite3.h>
115
116#if USE_LIBCLANG
117#if defined(__GNUC__)
118#pragma GCC diagnostic push
119#pragma GCC diagnostic ignored "-Wshadow"
120#endif
121#include <clang/Basic/Version.h>
122#if defined(__GNUC__)
123#pragma GCC diagnostic pop
124#endif
125#endif
126
127// provided by the generated file resources.cpp
128extern void initResources();
129
130#if !defined(_WIN32) || defined(__CYGWIN__)
131#include <signal.h>
132#define HAS_SIGNALS
133#endif
134
135// globally accessible variables
147FileNameLinkedMap *Doxygen::includeNameLinkedMap = nullptr; // include names
153FileNameLinkedMap *Doxygen::plantUmlFileNameLinkedMap = nullptr;// plantuml files
155StringMap Doxygen::tagDestinationMap; // all tag locations
156StringUnorderedSet Doxygen::tagFileSet; // all tag file names
157StringUnorderedSet Doxygen::expandAsDefinedSet; // all macros that should be expanded
158MemberGroupInfoMap Doxygen::memberGroupInfoMap; // dictionary of the member groups heading
159std::unique_ptr<PageDef> Doxygen::mainPage;
160std::unique_ptr<NamespaceDef> Doxygen::globalNamespaceDef;
182std::mutex Doxygen::addExampleMutex;
184
185// locally accessible globals
186static std::multimap< std::string, const Entry* > g_classEntries;
188static OutputList *g_outputList = nullptr; // list of output generating objects
189static StringSet g_usingDeclarations; // used classes
190static bool g_successfulRun = FALSE;
191static bool g_dumpSymbolMap = FALSE;
193static bool g_singleComment=false;
194
195
196
197// keywords recognized as compounds
199{ "template class", "template struct", "class", "struct", "union", "interface", "exception" };
200
202{
203 g_inputFiles.clear();
204 //g_excludeNameDict.clear();
205 //delete g_outputList; g_outputList=nullptr;
206
211 Doxygen::pageLinkedMap->clear();
224 Doxygen::mainPage.reset();
226}
227
229{
230 public:
232 void begin(const char *name)
233 {
234 msg("{}", name);
235 stats.emplace_back(name,0);
236 startTime = std::chrono::steady_clock::now();
237 }
238 void end()
239 {
240 std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
241 stats.back().elapsed = static_cast<double>(std::chrono::duration_cast<
242 std::chrono::microseconds>(endTime - startTime).count())/1000000.0;
243 warn_flush();
244 }
245 void print()
246 {
247 bool restore=FALSE;
249 {
251 restore=TRUE;
252 }
253 msg("----------------------\n");
254 for (const auto &s : stats)
255 {
256 msg("Spent {:.6f} seconds in {}",s.elapsed,s.name);
257 }
258 if (restore) Debug::setFlag(Debug::Time);
259 }
260 private:
261 struct stat
262 {
263 const char *name;
264 double elapsed;
265 //stat() : name(nullptr),elapsed(0) {}
266 stat(const char *n, double el) : name(n),elapsed(el) {}
267 };
268 std::vector<stat> stats;
269 std::chrono::steady_clock::time_point startTime;
271
272
273static void addMemberDocs(const Entry *root,MemberDefMutable *md, const QCString &funcDecl,
274 const ArgumentList *al,bool over_load,TypeSpecifier spec);
275static void findMember(const Entry *root,
276 const QCString &relates,
277 const QCString &type,
278 const QCString &args,
279 QCString funcDecl,
280 bool overloaded,
281 bool isFunc
282 );
283
290
291
292static bool findClassRelation(
293 const Entry *root,
294 Definition *context,
295 ClassDefMutable *cd,
296 const BaseInfo *bi,
297 const TemplateNameMap &templateNames,
298 /*bool insertUndocumented*/
300 bool isArtificial
301 );
302
303//----------------------------------------------------------------------------
304
306 FileDef *fileScope,const TagInfo *tagInfo);
307static void resolveTemplateInstanceInType(const Entry *root,const Definition *scope,const MemberDef *md);
308
309static void addPageToContext(PageDef *pd,Entry *root)
310{
311 if (root->parent()) // add the page to it's scope
312 {
313 QCString scope = root->parent()->name;
314 if (root->parent()->section.isPackageDoc())
315 {
316 scope=substitute(scope,".","::");
317 }
318 scope = stripAnonymousNamespaceScope(scope);
319 scope+="::"+pd->name();
321 if (d)
322 {
323 pd->setPageScope(d);
324 }
325 }
326}
327
328static void addRelatedPage(Entry *root)
329{
330 GroupDef *gd=nullptr;
331 for (const Grouping &g : root->groups)
332 {
333 if (!g.groupname.isEmpty() && (gd=Doxygen::groupLinkedMap->find(g.groupname))) break;
334 }
335 //printf("---> addRelatedPage() %s gd=%p\n",qPrint(root->name),gd);
336 QCString doc=root->doc+root->inbodyDocs;
337
338 PageDef *pd = addRelatedPage(root->name,root->args,doc,
339 root->docFile,
340 root->docLine,
341 root->startLine,
342 root->sli,
343 gd,root->tagInfo(),
344 FALSE,
345 root->lang
346 );
347 if (pd)
348 {
349 pd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
351 pd->setLocalToc(root->localToc);
352 addPageToContext(pd,root);
353 }
354}
355
356static void buildGroupListFiltered(const Entry *root,bool additional, bool includeExternal)
357{
358 if (root->section.isGroupDoc() && !root->name.isEmpty() &&
359 ((!includeExternal && root->tagInfo()==nullptr) ||
360 ( includeExternal && root->tagInfo()!=nullptr))
361 )
362 {
363 AUTO_TRACE("additional={} includeExternal={}",additional,includeExternal);
364 if ((root->groupDocType==Entry::GROUPDOC_NORMAL && !additional) ||
365 (root->groupDocType!=Entry::GROUPDOC_NORMAL && additional))
366 {
367 GroupDef *gd = Doxygen::groupLinkedMap->find(root->name);
368 AUTO_TRACE_ADD("Processing group '{}':'{}' gd={}", root->type,root->name,(void*)gd);
369
370 if (gd)
371 {
372 if ( !gd->hasGroupTitle() )
373 {
374 gd->setGroupTitle( root->type );
375 }
376 else if ( root->type.length() > 0 && root->name != root->type && gd->groupTitle() != root->type )
377 {
378 warn( root->fileName,root->startLine,
379 "group {}: ignoring title \"{}\" that does not match old title \"{}\"",
380 root->name, root->type, gd->groupTitle() );
381 }
382 gd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
383 gd->setDocumentation( root->doc, root->docFile, root->docLine );
384 gd->setInbodyDocumentation( root->inbodyDocs, root->inbodyFile, root->inbodyLine );
386 gd->setRefItems(root->sli);
387 gd->setLanguage(root->lang);
389 {
390 root->commandOverrides.apply_groupGraph([&](bool b) { gd->overrideGroupGraph(b); });
391 }
392 }
393 else
394 {
395 if (root->tagInfo())
396 {
397 gd = Doxygen::groupLinkedMap->add(root->name,
398 std::unique_ptr<GroupDef>(
399 createGroupDef(root->fileName,root->startLine,root->name,root->type,root->tagInfo()->fileName)));
400 gd->setReference(root->tagInfo()->tagName);
401 }
402 else
403 {
404 gd = Doxygen::groupLinkedMap->add(root->name,
405 std::unique_ptr<GroupDef>(
406 createGroupDef(root->fileName,root->startLine,root->name,root->type)));
407 }
408 gd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
409 // allow empty docs for group
410 gd->setDocumentation(!root->doc.isEmpty() ? root->doc : QCString(" "),root->docFile,root->docLine,FALSE);
411 gd->setInbodyDocumentation( root->inbodyDocs, root->inbodyFile, root->inbodyLine );
413 gd->setRefItems(root->sli);
414 gd->setLanguage(root->lang);
416 {
417 root->commandOverrides.apply_groupGraph([&](bool b) { gd->overrideGroupGraph(b); });
418 }
419 }
420 }
421 }
422 for (const auto &e : root->children()) buildGroupListFiltered(e.get(),additional,includeExternal);
423}
424
425static void buildGroupList(const Entry *root)
426{
427 // --- first process only local groups
428 // first process the @defgroups blocks
430 // then process the @addtogroup, @weakgroup blocks
432
433 // --- then also process external groups
434 // first process the @defgroups blocks
436 // then process the @addtogroup, @weakgroup blocks
438}
439
440static void findGroupScope(const Entry *root)
441{
442 if (root->section.isGroupDoc() && !root->name.isEmpty() &&
443 root->parent() && !root->parent()->name.isEmpty())
444 {
445 GroupDef *gd = Doxygen::groupLinkedMap->find(root->name);
446 if (gd)
447 {
448 QCString scope = root->parent()->name;
449 if (root->parent()->section.isPackageDoc())
450 {
451 scope=substitute(scope,".","::");
452 }
453 scope = stripAnonymousNamespaceScope(scope);
454 scope+="::"+gd->name();
456 if (d)
457 {
458 gd->setGroupScope(d);
459 }
460 }
461 }
462 for (const auto &e : root->children()) findGroupScope(e.get());
463}
464
465static void organizeSubGroupsFiltered(const Entry *root,bool additional)
466{
467 if (root->section.isGroupDoc() && !root->name.isEmpty())
468 {
469 AUTO_TRACE("additional={}",additional);
470 if ((root->groupDocType==Entry::GROUPDOC_NORMAL && !additional) ||
471 (root->groupDocType!=Entry::GROUPDOC_NORMAL && additional))
472 {
473 GroupDef *gd = Doxygen::groupLinkedMap->find(root->name);
474 if (gd)
475 {
476 AUTO_TRACE_ADD("adding {} to group {}",root->name,gd->name());
477 addGroupToGroups(root,gd);
478 }
479 }
480 }
481 for (const auto &e : root->children()) organizeSubGroupsFiltered(e.get(),additional);
482}
483
484static void organizeSubGroups(const Entry *root)
485{
486 //printf("Defining groups\n");
487 // first process the @defgroups blocks
489 //printf("Additional groups\n");
490 // then process the @addtogroup, @weakgroup blocks
492}
493
494//----------------------------------------------------------------------
495
496static void buildFileList(const Entry *root)
497{
498 if ((root->section.isFileDoc() || (root->section.isFile() && Config_getBool(EXTRACT_ALL))) &&
499 !root->name.isEmpty() && !root->tagInfo() // skip any file coming from tag files
500 )
501 {
502 bool ambig = false;
504 if (!fd || ambig)
505 {
506 bool save_ambig = ambig;
507 // use the directory of the file to see if the described file is in the same
508 // directory as the describing file.
509 QCString fn = root->fileName;
510 int newIndex=fn.findRev('/');
511 if (newIndex<0)
512 {
513 fn = root->name;
514 }
515 else
516 {
517 fn = fn.left(newIndex)+"/"+root->name;
518 }
520 if (!fd) ambig = save_ambig;
521 }
522 //printf("**************** root->name=%s fd=%p\n",qPrint(root->name),(void*)fd);
523 if (fd && !ambig)
524 {
525 //printf("Adding documentation!\n");
526 // using FALSE in setDocumentation is small hack to make sure a file
527 // is documented even if a \file command is used without further
528 // documentation
529 fd->setDocumentation(root->doc,root->docFile,root->docLine,FALSE);
530 fd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
532 fd->setRefItems(root->sli);
533 root->commandOverrides.apply_includeGraph ([&](bool b) { fd->overrideIncludeGraph(b); });
534 root->commandOverrides.apply_includedByGraph([&](bool b) { fd->overrideIncludedByGraph(b); });
535 for (const Grouping &g : root->groups)
536 {
537 GroupDef *gd=nullptr;
538 if (!g.groupname.isEmpty() && (gd=Doxygen::groupLinkedMap->find(g.groupname)))
539 {
540 if (!gd->containsFile(fd))
541 {
542 gd->addFile(fd);
543 fd->makePartOfGroup(gd);
544 //printf("File %s: in group %s\n",qPrint(fd->name()),qPrint(gd->name()));
545 }
546 }
547 else if (!gd && g.pri == Grouping::GROUPING_INGROUP)
548 {
549 warn(root->fileName, root->startLine,
550 "Found non-existing group '{}' for the command '{}', ignoring command",
552 );
553 }
554 }
555 }
556 else
557 {
559 text.sprintf("the name '%s' supplied as "
560 "the argument in the \\file statement ",
561 qPrint(root->name));
562 if (ambig) // name is ambiguous
563 {
564 text+="matches the following input files:\n";
566 text+="\n";
567 text+="Please use a more specific name by "
568 "including a (larger) part of the path!";
569 }
570 else // name is not an input file
571 {
572 text+="is not an input file";
573 }
574 warn(root->fileName,root->startLine,"{}", text);
575 }
576 }
577 for (const auto &e : root->children()) buildFileList(e.get());
578}
579
580template<class DefMutable>
581static void addIncludeFile(DefMutable *cd,FileDef *ifd,const Entry *root)
582{
583 if (
584 (!root->doc.stripWhiteSpace().isEmpty() ||
585 !root->brief.stripWhiteSpace().isEmpty() ||
586 Config_getBool(EXTRACT_ALL)
587 ) && root->protection!=Protection::Private
588 )
589 {
590 //printf(">>>>>> includeFile=%s\n",qPrint(root->includeFile));
591
592 bool local=Config_getBool(FORCE_LOCAL_INCLUDES);
593 QCString includeFile = root->includeFile;
594 if (!includeFile.isEmpty() && includeFile.at(0)=='"')
595 {
596 local = TRUE;
597 includeFile=includeFile.mid(1,includeFile.length()-2);
598 }
599 else if (!includeFile.isEmpty() && includeFile.at(0)=='<')
600 {
601 local = FALSE;
602 includeFile=includeFile.mid(1,includeFile.length()-2);
603 }
604
605 bool ambig = false;
606 FileDef *fd=nullptr;
607 // see if we need to include a verbatim copy of the header file
608 //printf("root->includeFile=%s\n",qPrint(root->includeFile));
609 if (!includeFile.isEmpty() &&
610 (fd=findFileDef(Doxygen::inputNameLinkedMap,includeFile,ambig))==nullptr
611 )
612 { // explicit request
613 QCString text;
614 text.sprintf("the name '%s' supplied as "
615 "the argument of the \\class, \\struct, \\union, or \\include command ",
616 qPrint(includeFile)
617 );
618 if (ambig) // name is ambiguous
619 {
620 text+="matches the following input files:\n";
622 text+="\n";
623 text+="Please use a more specific name by "
624 "including a (larger) part of the path!";
625 }
626 else // name is not an input file
627 {
628 text+="is not an input file";
629 }
630 warn(root->fileName,root->startLine, "{}", text);
631 }
632 else if (includeFile.isEmpty() && ifd &&
633 // see if the file extension makes sense
634 guessSection(ifd->name()).isHeader())
635 { // implicit assumption
636 fd=ifd;
637 }
638
639 // if a file is found, we mark it as a source file.
640 if (fd)
641 {
642 QCString iName = !root->includeName.isEmpty() ?
643 root->includeName : includeFile;
644 if (!iName.isEmpty()) // user specified include file
645 {
646 if (iName.at(0)=='<') local=FALSE; // explicit override
647 else if (iName.at(0)=='"') local=TRUE;
648 if (iName.at(0)=='"' || iName.at(0)=='<')
649 {
650 iName=iName.mid(1,iName.length()-2); // strip quotes or brackets
651 }
652 if (iName.isEmpty())
653 {
654 iName=fd->name();
655 }
656 }
657 else if (!Config_getList(STRIP_FROM_INC_PATH).empty())
658 {
660 }
661 else // use name of the file containing the class definition
662 {
663 iName=fd->name();
664 }
665 if (fd->generateSourceFile()) // generate code for header
666 {
667 cd->setIncludeFile(fd,iName,local,!root->includeName.isEmpty());
668 }
669 else // put #include in the class documentation without link
670 {
671 cd->setIncludeFile(nullptr,iName,local,TRUE);
672 }
673 }
674 }
675}
676
677
679{
680 size_t l = s.length();
681 int count=0;
682 int round=0;
683 QCString result;
684 for (size_t i=0;i<l;i++)
685 {
686 char c=s.at(i);
687 if (c=='(') round++;
688 else if (c==')' && round>0) round--;
689 else if (c=='<' && round==0) count++;
690 if (count==0)
691 {
692 result+=c;
693 }
694 if (c=='>' && round==0 && count>0) count--;
695 }
696 //printf("stripTemplateSpecifiers(%s)=%s\n",qPrint(s),qPrint(result));
697 return result;
698}
699
700/*! returns the Definition object belonging to the first \a level levels of
701 * full qualified name \a name. Creates an artificial scope if the scope is
702 * not found and set the parent/child scope relation if the scope is found.
703 */
704[[maybe_unused]]
705static Definition *buildScopeFromQualifiedName(const QCString &name_,SrcLangExt lang,const TagInfo *tagInfo)
706{
707 QCString name = stripTemplateSpecifiers(name_);
708 name.stripPrefix("::");
709 int level = name.contains("::");
710 //printf("buildScopeFromQualifiedName(%s) level=%d\n",qPrint(name),level);
711 int i=0, p=0, l=0;
713 QCString fullScope;
714 while (i<level)
715 {
716 int idx=getScopeFragment(name,p,&l);
717 if (idx==-1) return prevScope;
718 QCString nsName = name.mid(idx,l);
719 if (nsName.isEmpty()) return prevScope;
720 if (!fullScope.isEmpty()) fullScope+="::";
721 fullScope+=nsName;
722 NamespaceDef *nd=Doxygen::namespaceLinkedMap->find(fullScope);
723 DefinitionMutable *innerScope = toDefinitionMutable(nd);
724 ClassDef *cd=nullptr;
725 if (nd==nullptr) cd = getClass(fullScope);
726 if (nd==nullptr && cd) // scope is a class
727 {
728 innerScope = toDefinitionMutable(cd);
729 }
730 else if (nd==nullptr && cd==nullptr && fullScope.find('<')==-1) // scope is not known and could be a namespace!
731 {
732 // introduce bogus namespace
733 //printf("++ adding dummy namespace %s to %s tagInfo=%p\n",qPrint(nsName),qPrint(prevScope->name()),(void*)tagInfo);
734 NamespaceDefMutable *newNd=
736 Doxygen::namespaceLinkedMap->add(fullScope,
738 "[generated]",1,1,fullScope,
739 tagInfo?tagInfo->tagName:QCString(),
740 tagInfo?tagInfo->fileName:QCString())));
741 if (newNd)
742 {
743 newNd->setLanguage(lang);
744 newNd->setArtificial(TRUE);
745 // add namespace to the list
746 innerScope = newNd;
747 }
748 }
749 else // scope is a namespace
750 {
751 }
752 if (innerScope)
753 {
754 // make the parent/child scope relation
755 DefinitionMutable *prevScopeMutable = toDefinitionMutable(prevScope);
756 if (prevScopeMutable)
757 {
758 prevScopeMutable->addInnerCompound(toDefinition(innerScope));
759 }
760 innerScope->setOuterScope(prevScope);
761 }
762 else // current scope is a class, so return only the namespace part...
763 {
764 return prevScope;
765 }
766 // proceed to the next scope fragment
767 p=idx+l+2;
768 prevScope=toDefinition(innerScope);
769 i++;
770 }
771 return prevScope;
772}
773
775 FileDef *fileScope,const TagInfo *tagInfo)
776{
777 //printf("<findScopeFromQualifiedName(%s,%s)\n",startScope ? qPrint(startScope->name()) : 0, qPrint(n));
778 Definition *resultScope=toDefinition(startScope);
779 if (resultScope==nullptr) resultScope=Doxygen::globalScope;
781 int l1 = 0;
782 int i1 = getScopeFragment(scope,0,&l1);
783 if (i1==-1)
784 {
785 //printf(">no fragments!\n");
786 return resultScope;
787 }
788 int p=i1+l1,l2=0,i2=0;
789 while ((i2=getScopeFragment(scope,p,&l2))!=-1)
790 {
791 QCString nestedNameSpecifier = scope.mid(i1,l1);
792 Definition *orgScope = resultScope;
793 //printf(" nestedNameSpecifier=%s\n",qPrint(nestedNameSpecifier));
794 resultScope = const_cast<Definition*>(resultScope->findInnerCompound(nestedNameSpecifier));
795 //printf(" resultScope=%p\n",resultScope);
796 if (resultScope==nullptr)
797 {
798 if (orgScope==Doxygen::globalScope && fileScope && !fileScope->getUsedNamespaces().empty())
799 // also search for used namespaces
800 {
801 for (const auto &nd : fileScope->getUsedNamespaces())
802 {
804 if (mnd)
805 {
806 resultScope = findScopeFromQualifiedName(toNamespaceDefMutable(nd),n,fileScope,tagInfo);
807 if (resultScope!=nullptr) break;
808 }
809 }
810 if (resultScope)
811 {
812 // for a nested class A::I in used namespace N, we get
813 // N::A::I while looking for A, so we should compare
814 // resultScope->name() against scope.left(i2+l2)
815 //printf(" -> result=%s scope=%s\n",qPrint(resultScope->name()),qPrint(scope));
816 if (rightScopeMatch(resultScope->name(),scope.left(i2+l2)))
817 {
818 break;
819 }
820 goto nextFragment;
821 }
822 }
823
824 // also search for used classes. Complication: we haven't been able
825 // to put them in the right scope yet, because we are still resolving
826 // the scope relations!
827 // Therefore loop through all used classes and see if there is a right
828 // scope match between the used class and nestedNameSpecifier.
829 for (const auto &usedName : g_usingDeclarations)
830 {
831 //printf("Checking using class %s\n",usedName.c_str());
832 if (rightScopeMatch(usedName.c_str(),nestedNameSpecifier))
833 {
834 // ui.currentKey() is the fully qualified name of nestedNameSpecifier
835 // so use this instead.
836 QCString fqn = QCString(usedName) + scope.right(scope.length()-p);
837 resultScope = buildScopeFromQualifiedName(fqn,startScope->getLanguage(),nullptr);
838 //printf("Creating scope from fqn=%s result %p\n",qPrint(fqn),resultScope);
839 if (resultScope)
840 {
841 //printf("> Match! resultScope=%s\n",qPrint(resultScope->name()));
842 return resultScope;
843 }
844 }
845 }
846
847 //printf("> name %s not found in scope %s\n",qPrint(nestedNameSpecifier),qPrint(orgScope->name()));
848 return nullptr;
849 }
850 nextFragment:
851 i1=i2;
852 l1=l2;
853 p=i2+l2;
854 }
855 //printf(">findScopeFromQualifiedName scope %s\n",qPrint(resultScope->name()));
856 return resultScope;
857}
858
859std::unique_ptr<ArgumentList> getTemplateArgumentsFromName(
860 const QCString &name,
861 const ArgumentLists &tArgLists)
862{
863 // for each scope fragment, check if it is a template and advance through
864 // the list if so.
865 int i=0, p=0;
866 auto alIt = tArgLists.begin();
867 while ((i=name.find("::",p))!=-1 && alIt!=tArgLists.end())
868 {
870 if (nd==nullptr)
871 {
872 ClassDef *cd = getClass(name.left(i));
873 if (cd)
874 {
875 if (!cd->templateArguments().empty())
876 {
877 ++alIt;
878 }
879 }
880 }
881 p=i+2;
882 }
883 return alIt!=tArgLists.end() ?
884 std::make_unique<ArgumentList>(*alIt) :
885 std::unique_ptr<ArgumentList>();
886}
887
888static
890{
892
893 if (specifier.isStruct())
895 else if (specifier.isUnion())
896 sec=ClassDef::Union;
897 else if (specifier.isCategory())
899 else if (specifier.isInterface())
901 else if (specifier.isProtocol())
903 else if (specifier.isException())
905 else if (specifier.isService())
907 else if (specifier.isSingleton())
909
910 if (section.isUnionDoc())
911 sec=ClassDef::Union;
912 else if (section.isStructDoc())
914 else if (section.isInterfaceDoc())
916 else if (section.isProtocolDoc())
918 else if (section.isCategoryDoc())
920 else if (section.isExceptionDoc())
922 else if (section.isServiceDoc())
924 else if (section.isSingletonDoc())
926
927 return sec;
928}
929
930
931static void addClassToContext(const Entry *root)
932{
933 AUTO_TRACE("name={}",root->name);
934 FileDef *fd = root->fileDef();
935
936 QCString scName;
937 if (root->parent()->section.isScope())
938 {
939 scName=root->parent()->name;
940 }
941 // name without parent's scope
942 QCString fullName = root->name;
943
944 // strip off any template parameters (but not those for specializations)
945 int idx=fullName.find('>');
946 if (idx!=-1 && root->lang==SrcLangExt::CSharp) // mangle A<S,T>::N as A-2-g::N
947 {
948 fullName = mangleCSharpGenericName(fullName.left(idx+1))+fullName.mid(idx+1);
949 }
950 fullName=stripTemplateSpecifiersFromScope(fullName);
951
952 // name with scope (if not present already)
953 QCString qualifiedName = fullName;
954 if (!scName.isEmpty() && !leftScopeMatch(scName,fullName))
955 {
956 qualifiedName.prepend(scName+"::");
957 }
958
959 // see if we already found the class before
960 ClassDefMutable *cd = getClassMutable(qualifiedName);
961
962 AUTO_TRACE_ADD("Found class with name '{}', qualifiedName '{}'", cd ? cd->name() : root->name, qualifiedName);
963
964 if (cd)
965 {
966 fullName=cd->name();
967 AUTO_TRACE_ADD("Existing class '{}'",cd->name());
968 //if (cd->templateArguments()==0)
969 //{
970 // //printf("existing ClassDef tempArgList=%p specScope=%s\n",root->tArgList,qPrint(root->scopeSpec));
971 // cd->setTemplateArguments(tArgList);
972 //}
973
974 cd->setDocumentation(root->doc,root->docFile,root->docLine);
975 cd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
976 root->commandOverrides.apply_collaborationGraph([&](bool b ) { cd->overrideCollaborationGraph(b); });
977 root->commandOverrides.apply_inheritanceGraph ([&](CLASS_GRAPH_t gt) { cd->overrideInheritanceGraph(gt); });
978
979 if (!root->spec.isForwardDecl() && cd->isForwardDeclared())
980 {
981 cd->setDefFile(root->fileName,root->startLine,root->startColumn);
982 if (root->bodyLine!=-1)
983 {
984 cd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
985 cd->setBodyDef(fd);
986 }
987 }
988
989 if (cd->templateArguments().empty() || (cd->isForwardDeclared() && !root->spec.isForwardDecl()))
990 {
991 // this happens if a template class declared with @class is found
992 // before the actual definition or if a forward declaration has different template
993 // parameter names.
994 std::unique_ptr<ArgumentList> tArgList = getTemplateArgumentsFromName(cd->name(),root->tArgLists);
995 if (tArgList)
996 {
997 cd->setTemplateArguments(*tArgList);
998 }
999 }
1000 if (cd->requiresClause().isEmpty() && !root->req.isEmpty())
1001 {
1002 cd->setRequiresClause(root->req);
1003 }
1004
1006
1007 cd->setMetaData(root->metaData);
1008 }
1009 else // new class
1010 {
1012
1013 QCString className;
1014 QCString namespaceName;
1015 extractNamespaceName(fullName,className,namespaceName);
1016
1017 AUTO_TRACE_ADD("New class: fullname '{}' namespace '{}' name='{}' brief='{}' docs='{}'",
1018 fullName, namespaceName, className, Trace::trunc(root->brief), Trace::trunc(root->doc));
1019
1020 QCString tagName;
1021 QCString refFileName;
1022 const TagInfo *tagInfo = root->tagInfo();
1023 if (tagInfo)
1024 {
1025 tagName = tagInfo->tagName;
1026 refFileName = tagInfo->fileName;
1027 if (fullName.find("::")!=-1)
1028 // symbols imported via tag files may come without the parent scope,
1029 // so we artificially create it here
1030 {
1031 buildScopeFromQualifiedName(fullName,root->lang,tagInfo);
1032 }
1033 }
1034 std::unique_ptr<ArgumentList> tArgList;
1035 int i=0;
1036 if ((root->lang==SrcLangExt::CSharp || root->lang==SrcLangExt::Java) && (i=fullName.findRev('<'))!=-1)
1037 {
1038 // a Java/C# generic class looks like a C++ specialization, so we need to split the
1039 // name and template arguments here
1040 tArgList = stringToArgumentList(root->lang,fullName.mid(i));
1041 if (i!=-1 && root->lang==SrcLangExt::CSharp) // in C# A, A<T>, and A<T,S> are different classes, so we need some way to disguish them using this name mangling
1042 // A -> A
1043 // A<T> -> A-1-g
1044 // A<T,S> -> A-2-g
1045 {
1046 fullName=mangleCSharpGenericName(fullName);
1047 }
1048 else
1049 {
1050 fullName=fullName.left(i);
1051 }
1052 }
1053 else
1054 {
1055 tArgList = getTemplateArgumentsFromName(fullName,root->tArgLists);
1056 }
1057 // add class to the list
1058 cd = toClassDefMutable(
1059 Doxygen::classLinkedMap->add(fullName,
1060 createClassDef(tagInfo?tagName:root->fileName,root->startLine,root->startColumn,
1061 fullName,sec,tagName,refFileName,TRUE,root->spec.isEnum()) ));
1062 if (cd)
1063 {
1064 AUTO_TRACE_ADD("New class '{}' type={} #tArgLists={} tagInfo={} hidden={} artificial={}",
1065 fullName,cd->compoundTypeString(),root->tArgLists.size(),
1066 fmt::ptr(tagInfo),root->hidden,root->artificial);
1067 cd->setDocumentation(root->doc,root->docFile,root->docLine); // copy docs to definition
1068 cd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1069 cd->setLanguage(root->lang);
1070 cd->setId(root->id);
1071 cd->setHidden(root->hidden);
1072 cd->setArtificial(root->artificial);
1073 cd->setClassSpecifier(root->spec);
1074 cd->addQualifiers(root->qualifiers);
1075 cd->setTypeConstraints(root->typeConstr);
1076 root->commandOverrides.apply_collaborationGraph([&](bool b ) { cd->overrideCollaborationGraph(b); });
1077 root->commandOverrides.apply_inheritanceGraph ([&](CLASS_GRAPH_t gt) { cd->overrideInheritanceGraph(gt); });
1078
1079 if (tArgList)
1080 {
1081 cd->setTemplateArguments(*tArgList);
1082 }
1083 cd->setRequiresClause(root->req);
1084 cd->setProtection(root->protection);
1085 cd->setIsStatic(root->isStatic);
1086
1087 // file definition containing the class cd
1088 cd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
1089 cd->setBodyDef(fd);
1090
1091 cd->setMetaData(root->metaData);
1092
1093 cd->insertUsedFile(fd);
1094 }
1095 else
1096 {
1097 AUTO_TRACE_ADD("Class {} not added, already exists as alias", fullName);
1098 }
1099 }
1100
1101 if (cd)
1102 {
1104 if (!root->subGrouping) cd->setSubGrouping(FALSE);
1105 if (!root->spec.isForwardDecl())
1106 {
1107 if (cd->hasDocumentation())
1108 {
1109 addIncludeFile(cd,fd,root);
1110 }
1111 if (fd && root->section.isCompound())
1112 {
1113 AUTO_TRACE_ADD("Inserting class {} in file {} (root->fileName='{}')", cd->name(), fd->name(), root->fileName);
1114 cd->setFileDef(fd);
1115 fd->insertClass(cd);
1116 }
1117 }
1118 addClassToGroups(root,cd);
1120 cd->setRefItems(root->sli);
1121 }
1122}
1123
1124//----------------------------------------------------------------------
1125// build a list of all classes mentioned in the documentation
1126// and all classes that have a documentation block before their definition.
1127static void buildClassList(const Entry *root)
1128{
1129 if ((root->section.isCompound() || root->section.isObjcImpl()) && !root->name.isEmpty())
1130 {
1131 AUTO_TRACE();
1132 addClassToContext(root);
1133 }
1134 for (const auto &e : root->children()) buildClassList(e.get());
1135}
1136
1137static void buildClassDocList(const Entry *root)
1138{
1139 if ((root->section.isCompoundDoc()) && !root->name.isEmpty())
1140 {
1141 AUTO_TRACE();
1142 addClassToContext(root);
1143 }
1144 for (const auto &e : root->children()) buildClassDocList(e.get());
1145}
1146
1147//----------------------------------------------------------------------
1148// build a list of all classes mentioned in the documentation
1149// and all classes that have a documentation block before their definition.
1150
1151static void addConceptToContext(const Entry *root)
1152{
1153 AUTO_TRACE();
1154 FileDef *fd = root->fileDef();
1155
1156 QCString scName;
1157 if (root->parent()->section.isScope())
1158 {
1159 scName=root->parent()->name;
1160 }
1161
1162 // name with scope (if not present already)
1163 QCString qualifiedName = root->name;
1164 if (!scName.isEmpty() && !leftScopeMatch(qualifiedName,scName))
1165 {
1166 qualifiedName.prepend(scName+"::");
1167 }
1168
1169 // see if we already found the concept before
1170 ConceptDefMutable *cd = getConceptMutable(qualifiedName);
1171
1172 AUTO_TRACE_ADD("Found concept with name '{}' (qualifiedName='{}')", cd ? cd->name() : root->name, qualifiedName);
1173
1174 if (cd)
1175 {
1176 qualifiedName=cd->name();
1177 AUTO_TRACE_ADD("Existing concept '{}'",cd->name());
1178
1179 cd->setDocumentation(root->doc,root->docFile,root->docLine);
1180 cd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1181
1182 addIncludeFile(cd,fd,root);
1183 }
1184 else // new concept
1185 {
1186 QCString className;
1187 QCString namespaceName;
1188 extractNamespaceName(qualifiedName,className,namespaceName);
1189
1190 AUTO_TRACE_ADD("New concept: fullname '{}' namespace '{}' name='{}' brief='{}' docs='{}'",
1191 qualifiedName,namespaceName,className,root->brief,root->doc);
1192
1193 QCString tagName;
1194 QCString refFileName;
1195 const TagInfo *tagInfo = root->tagInfo();
1196 if (tagInfo)
1197 {
1198 tagName = tagInfo->tagName;
1199 refFileName = tagInfo->fileName;
1200 if (qualifiedName.find("::")!=-1)
1201 // symbols imported via tag files may come without the parent scope,
1202 // so we artificially create it here
1203 {
1204 buildScopeFromQualifiedName(qualifiedName,root->lang,tagInfo);
1205 }
1206 }
1207 std::unique_ptr<ArgumentList> tArgList = getTemplateArgumentsFromName(qualifiedName,root->tArgLists);
1208 // add concept to the list
1210 Doxygen::conceptLinkedMap->add(qualifiedName,
1211 createConceptDef(tagInfo?tagName:root->fileName,root->startLine,root->startColumn,
1212 qualifiedName,tagName,refFileName)));
1213 if (cd)
1214 {
1215 AUTO_TRACE_ADD("New concept '{}' #tArgLists={} tagInfo={}",
1216 qualifiedName,root->tArgLists.size(),fmt::ptr(tagInfo));
1217 cd->setDocumentation(root->doc,root->docFile,root->docLine); // copy docs to definition
1218 cd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1219 cd->setLanguage(root->lang);
1220 cd->setId(root->id);
1221 cd->setHidden(root->hidden);
1222 cd->setGroupId(root->mGrpId);
1223 if (tArgList)
1224 {
1225 cd->setTemplateArguments(*tArgList);
1226 }
1227 cd->setInitializer(root->initializer.str().c_str());
1228 // file definition containing the class cd
1229 cd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
1230 cd->setBodyDef(fd);
1231 addIncludeFile(cd,fd,root);
1232
1233 // also add namespace to the correct structural context
1234 Definition *d = findScopeFromQualifiedName(Doxygen::globalScope,qualifiedName,nullptr,tagInfo);
1236 {
1238 if (dm)
1239 {
1240 dm->addInnerCompound(cd);
1241 }
1242 cd->setOuterScope(d);
1243 }
1244 }
1245 else
1246 {
1247 AUTO_TRACE_ADD("Concept '{}' not added, already exists (as alias)", qualifiedName);
1248 }
1249 }
1250
1251 if (cd)
1252 {
1254 if (fd)
1255 {
1256 AUTO_TRACE_ADD("Inserting concept '{}' in file '{}' (root->fileName='{}')", cd->name(), fd->name(), root->fileName);
1257 cd->setFileDef(fd);
1258 fd->insertConcept(cd);
1259 }
1260 addConceptToGroups(root,cd);
1262 cd->setRefItems(root->sli);
1263 }
1264}
1265
1266static void findModuleDocumentation(const Entry *root)
1267{
1268 if (root->section.isModuleDoc())
1269 {
1270 AUTO_TRACE();
1272 }
1273 for (const auto &e : root->children()) findModuleDocumentation(e.get());
1274}
1275
1276static void buildConceptList(const Entry *root)
1277{
1278 if (root->section.isConcept())
1279 {
1280 AUTO_TRACE();
1281 addConceptToContext(root);
1282 }
1283 for (const auto &e : root->children()) buildConceptList(e.get());
1284}
1285
1286static void buildConceptDocList(const Entry *root)
1287{
1288 if (root->section.isConceptDoc())
1289 {
1290 AUTO_TRACE();
1291 addConceptToContext(root);
1292 }
1293 for (const auto &e : root->children()) buildConceptDocList(e.get());
1294}
1295
1296// This routine is to allow @ingroup X @{ concept A; concept B; @} to work
1297// (same also works for variable and functions because of logic in MemberGroup::insertMember)
1299{
1300 AUTO_TRACE();
1301 for (const auto &cd : *Doxygen::conceptLinkedMap)
1302 {
1303 if (cd->groupId()!=DOX_NOGROUP)
1304 {
1305 for (const auto &ocd : *Doxygen::conceptLinkedMap)
1306 {
1307 if (cd!=ocd && cd->groupId()==ocd->groupId() &&
1308 !cd->partOfGroups().empty() && ocd->partOfGroups().empty())
1309 {
1310 ConceptDefMutable *ocdm = toConceptDefMutable(ocd.get());
1311 if (ocdm)
1312 {
1313 for (const auto &gd : cd->partOfGroups())
1314 {
1315 if (gd)
1316 {
1317 AUTO_TRACE_ADD("making concept '{}' part of group '{}'",ocdm->name(),gd->name());
1318 ocdm->makePartOfGroup(gd);
1319 gd->addConcept(ocd.get());
1320 }
1321 }
1322 }
1323 }
1324 }
1325 }
1326 }
1327}
1328
1329//----------------------------------------------------------------------
1330
1332{
1333 ClassDefSet visitedClasses;
1334
1335 bool done=FALSE;
1336 //int iteration=0;
1337 while (!done)
1338 {
1339 done=TRUE;
1340 //++iteration;
1341 struct ClassAlias
1342 {
1343 ClassAlias(const QCString &name,std::unique_ptr<ClassDef> cd,DefinitionMutable *ctx) :
1344 aliasFullName(name),aliasCd(std::move(cd)), aliasContext(ctx) {}
1345 QCString aliasFullName;
1346 std::unique_ptr<ClassDef> aliasCd;
1347 DefinitionMutable *aliasContext;
1348 };
1349 std::vector<ClassAlias> aliases;
1350 for (const auto &icd : *Doxygen::classLinkedMap)
1351 {
1352 ClassDefMutable *cd = toClassDefMutable(icd.get());
1353 if (cd && visitedClasses.find(icd.get())==visitedClasses.end())
1354 {
1355 QCString name = stripAnonymousNamespaceScope(icd->name());
1356 //printf("processing=%s, iteration=%d\n",qPrint(cd->name()),iteration);
1357 // also add class to the correct structural context
1359 name,icd->getFileDef(),nullptr);
1360 if (d)
1361 {
1362 //printf("****** adding %s to scope %s in iteration %d\n",qPrint(cd->name()),qPrint(d->name()),iteration);
1364 if (dm)
1365 {
1366 dm->addInnerCompound(cd);
1367 }
1368 cd->setOuterScope(d);
1369
1370 // for inline namespace add an alias of the class to the outer scope
1372 {
1374 //printf("nd->isInline()=%d\n",nd->isInline());
1375 if (nd && nd->isInline())
1376 {
1377 d = d->getOuterScope();
1378 if (d)
1379 {
1380 dm = toDefinitionMutable(d);
1381 if (dm)
1382 {
1383 auto aliasCd = createClassDefAlias(d,cd);
1384 QCString aliasFullName = d->qualifiedName()+"::"+aliasCd->localName();
1385 aliases.emplace_back(aliasFullName,std::move(aliasCd),dm);
1386 //printf("adding %s to %s as %s\n",qPrint(aliasCd->name()),qPrint(d->name()),qPrint(aliasFullName));
1387 }
1388 }
1389 }
1390 else
1391 {
1392 break;
1393 }
1394 }
1395
1396 visitedClasses.insert(icd.get());
1397 done=FALSE;
1398 }
1399 //else
1400 //{
1401 // printf("****** ignoring %s: scope not (yet) found in iteration %d\n",qPrint(cd->name()),iteration);
1402 //}
1403 }
1404 }
1405 // add aliases
1406 for (auto &alias : aliases)
1407 {
1408 ClassDef *aliasCd = Doxygen::classLinkedMap->add(alias.aliasFullName,std::move(alias.aliasCd));
1409 if (aliasCd)
1410 {
1411 alias.aliasContext->addInnerCompound(aliasCd);
1412 }
1413 }
1414 }
1415
1416 //give warnings for unresolved compounds
1417 for (const auto &icd : *Doxygen::classLinkedMap)
1418 {
1419 ClassDefMutable *cd = toClassDefMutable(icd.get());
1420 if (cd && visitedClasses.find(icd.get())==visitedClasses.end())
1421 {
1423 /// create the scope artificially
1424 // anyway, so we can at least relate scopes properly.
1425 Definition *d = buildScopeFromQualifiedName(name,cd->getLanguage(),nullptr);
1426 if (d && d!=cd && !cd->getDefFileName().isEmpty())
1427 // avoid recursion in case of redundant scopes, i.e: namespace N { class N::C {}; }
1428 // for this case doxygen assumes the existence of a namespace N::N in which C is to be found!
1429 // also avoid warning for stuff imported via a tagfile.
1430 {
1432 if (dm)
1433 {
1434 dm->addInnerCompound(cd);
1435 }
1436 cd->setOuterScope(d);
1437 warn(cd->getDefFileName(),cd->getDefLine(),
1438 "Incomplete input: scope for class {} not found!{}",name,
1439 name.startsWith("std::") ? " Try enabling BUILTIN_STL_SUPPORT." : ""
1440 );
1441 }
1442 }
1443 }
1444}
1445
1447{
1448 //bool inlineGroupedClasses = Config_getBool(INLINE_GROUPED_CLASSES);
1449 //if (!inlineGroupedClasses) return;
1450 //printf("** distributeClassGroupRelations()\n");
1451
1452 ClassDefSet visitedClasses;
1453 for (const auto &cd : *Doxygen::classLinkedMap)
1454 {
1455 //printf("Checking %s\n",qPrint(cd->name()));
1456 // distribute the group to nested classes as well
1457 if (visitedClasses.find(cd.get())==visitedClasses.end() && !cd->partOfGroups().empty())
1458 {
1459 //printf(" Candidate for merging\n");
1460 GroupDef *gd = cd->partOfGroups().front();
1461 for (auto &ncd : cd->getClasses())
1462 {
1464 if (ncdm && ncdm->partOfGroups().empty())
1465 {
1466 //printf(" Adding %s to group '%s'\n",qPrint(ncd->name()),
1467 // gd->groupTitle());
1468 ncdm->makePartOfGroup(gd);
1469 gd->addClass(ncdm);
1470 }
1471 }
1472 visitedClasses.insert(cd.get()); // only visit every class once
1473 }
1474 }
1475}
1476
1477//----------------------------
1478
1479static ClassDefMutable *createTagLessInstance(const ClassDef *rootCd,const ClassDef *templ,const QCString &fieldName)
1480{
1481 QCString fullName = removeAnonymousScopes(templ->name());
1482 if (fullName.endsWith("::")) fullName=fullName.left(fullName.length()-2);
1483 fullName+="."+fieldName;
1484
1485 //printf("** adding class %s based on %s\n",qPrint(fullName),qPrint(templ->name()));
1487 Doxygen::classLinkedMap->add(fullName,
1489 templ->getDefLine(),
1490 templ->getDefColumn(),
1491 fullName,
1492 templ->compoundType())));
1493 if (cd)
1494 {
1495 cd->setDocumentation(templ->documentation(),templ->docFile(),templ->docLine()); // copy docs to definition
1496 cd->setBriefDescription(templ->briefDescription(),templ->briefFile(),templ->briefLine());
1497 cd->setLanguage(templ->getLanguage());
1498 cd->setBodySegment(templ->getDefLine(),templ->getStartBodyLine(),templ->getEndBodyLine());
1499 cd->setBodyDef(templ->getBodyDef());
1500
1501 cd->setOuterScope(rootCd->getOuterScope());
1502 if (rootCd->getOuterScope()!=Doxygen::globalScope)
1503 {
1504 DefinitionMutable *outerScope = toDefinitionMutable(rootCd->getOuterScope());
1505 if (outerScope)
1506 {
1507 outerScope->addInnerCompound(cd);
1508 }
1509 }
1510
1511 FileDef *fd = templ->getFileDef();
1512 if (fd)
1513 {
1514 cd->setFileDef(fd);
1515 fd->insertClass(cd);
1516 }
1517 for (auto &gd : rootCd->partOfGroups())
1518 {
1519 cd->makePartOfGroup(gd);
1520 gd->addClass(cd);
1521 }
1522
1523 MemberList *ml = templ->getMemberList(MemberListType::PubAttribs());
1524 if (ml)
1525 {
1526 for (const auto &md : *ml)
1527 {
1528 //printf(" Member %s type=%s\n",qPrint(md->name()),md->typeString());
1529 auto newMd = createMemberDef(md->getDefFileName(),md->getDefLine(),md->getDefColumn(),
1530 md->typeString(),md->name(),md->argsString(),md->excpString(),
1531 md->protection(),md->virtualness(),md->isStatic(),Relationship::Member,
1532 md->memberType(),
1533 ArgumentList(),ArgumentList(),"");
1534 MemberDefMutable *imd = toMemberDefMutable(newMd.get());
1535 imd->setMemberClass(cd);
1536 imd->setDocumentation(md->documentation(),md->docFile(),md->docLine());
1537 imd->setBriefDescription(md->briefDescription(),md->briefFile(),md->briefLine());
1538 imd->setInbodyDocumentation(md->inbodyDocumentation(),md->inbodyFile(),md->inbodyLine());
1539 imd->setMemberSpecifiers(md->getMemberSpecifiers());
1540 imd->setVhdlSpecifiers(md->getVhdlSpecifiers());
1541 imd->setMemberGroupId(md->getMemberGroupId());
1542 imd->setInitializer(md->initializer());
1543 imd->setRequiresClause(md->requiresClause());
1544 imd->setMaxInitLines(md->initializerLines());
1545 imd->setBitfields(md->bitfieldString());
1546 imd->setLanguage(md->getLanguage());
1547 cd->insertMember(imd);
1548 MemberName *mn = Doxygen::memberNameLinkedMap->add(md->name());
1549 mn->push_back(std::move(newMd));
1550 }
1551 }
1552 }
1553 return cd;
1554}
1555
1556/** Look through the members of class \a cd and its public members.
1557 * If there is a member m of a tag less struct/union,
1558 * then we create a duplicate of the struct/union with the name of the
1559 * member to identify it.
1560 * So if cd has name S, then the tag less struct/union will get name S.m
1561 * Since tag less structs can be nested we need to call this function
1562 * recursively. Later on we need to patch the member types so we keep
1563 * track of the hierarchy of classes we create.
1564 */
1565static void processTagLessClasses(const ClassDef *rootCd,
1566 const ClassDef *cd,
1567 ClassDefMutable *tagParentCd,
1568 const QCString &prefix,int count)
1569{
1570 //printf("%d: processTagLessClasses %s\n",count,qPrint(cd->name()));
1571 //printf("checking members for %s\n",qPrint(cd->name()));
1572 if (tagParentCd && !cd->getClasses().empty())
1573 {
1574 MemberList *ml = cd->getMemberList(MemberListType::PubAttribs());
1575 if (ml)
1576 {
1577 int pos=0;
1578 for (const auto &md : *ml)
1579 {
1580 QCString type = md->typeString();
1581 if (type.find("::@")!=-1) // member of tag less struct/union
1582 {
1583 for (const auto &icd : cd->getClasses())
1584 {
1585 //printf(" member %s: type='%s'\n",qPrint(md->name()),qPrint(type));
1586 //printf(" comparing '%s'<->'%s'\n",qPrint(type),qPrint(icd->name()));
1587 if (type.find(icd->name())!=-1) // matching tag less struct/union
1588 {
1589 QCString name = md->name();
1590 if (md->isAnonymous()) name = "__unnamed" + QCString().setNum(pos++)+"__";
1591 if (!prefix.isEmpty()) name.prepend(prefix+".");
1592 //printf(" found %s for class %s\n",qPrint(name),qPrint(cd->name()));
1593 ClassDefMutable *ncd = createTagLessInstance(rootCd,icd,name);
1594 if (ncd)
1595 {
1596 processTagLessClasses(rootCd,icd,ncd,name,count+1);
1597 //printf(" addTagged %s to %s\n",qPrint(ncd->name()),qPrint(tagParentCd->name()));
1598 ncd->setTagLessReference(icd);
1599
1600 // replace tag-less type for generated/original member
1601 // by newly created class name.
1602 // note the difference between changing cd and tagParentCd.
1603 // for the initial call this is the same pointer, but for
1604 // recursive calls cd is the original tag-less struct (of which
1605 // there is only one instance) and tagParentCd is the newly
1606 // generated tagged struct of which there can be multiple instances!
1607 MemberList *pml = tagParentCd->getMemberList(MemberListType::PubAttribs());
1608 if (pml)
1609 {
1610 for (const auto &pmd : *pml)
1611 {
1613 if (pmdm && pmd->name()==md->name())
1614 {
1615 pmdm->setAccessorType(ncd,substitute(pmd->typeString(),icd->name(),ncd->name()));
1616 //pmd->setType(substitute(pmd->typeString(),icd->name(),ncd->name()));
1617 }
1618 }
1619 }
1620 }
1621 }
1622 }
1623 }
1624 }
1625 }
1626 }
1627}
1628
1629static void findTagLessClasses(std::vector<ClassDefMutable*> &candidates,ClassDef *cd)
1630{
1631 for (const auto &icd : cd->getClasses())
1632 {
1633 if (icd->name().find("@")==-1) // process all non-anonymous inner classes
1634 {
1635 findTagLessClasses(candidates,icd);
1636 }
1637 }
1638
1640 if (cdm)
1641 {
1642 candidates.push_back(cdm);
1643 }
1644}
1645
1647{
1648 std::vector<ClassDefMutable *> candidates;
1649 for (auto &cd : *Doxygen::classLinkedMap)
1650 {
1651 Definition *scope = cd->getOuterScope();
1652 if (scope && scope->definitionType()!=Definition::TypeClass) // that is not nested
1653 {
1654 findTagLessClasses(candidates,cd.get());
1655 }
1656 }
1657
1658 // since processTagLessClasses is potentially adding classes to Doxygen::classLinkedMap
1659 // we need to call it outside of the loop above, otherwise the iterator gets invalidated!
1660 for (auto &cd : candidates)
1661 {
1662 processTagLessClasses(cd,cd,cd,"",0); // process tag less inner struct/classes
1663 }
1664}
1665
1666
1667//----------------------------------------------------------------------
1668// build a list of all namespaces mentioned in the documentation
1669// and all namespaces that have a documentation block before their definition.
1670static void buildNamespaceList(const Entry *root)
1671{
1672 if (
1673 (root->section.isNamespace() ||
1674 root->section.isNamespaceDoc() ||
1675 root->section.isPackageDoc()
1676 ) &&
1677 !root->name.isEmpty()
1678 )
1679 {
1680 AUTO_TRACE("name={}",root->name);
1681
1682 QCString fName = root->name;
1683 if (root->section.isPackageDoc())
1684 {
1685 fName=substitute(fName,".","::");
1686 }
1687
1688 QCString fullName = stripAnonymousNamespaceScope(fName);
1689 if (!fullName.isEmpty())
1690 {
1691 AUTO_TRACE_ADD("Found namespace {} in {} at line {}",root->name,root->fileName,root->startLine);
1692 NamespaceDef *ndi = Doxygen::namespaceLinkedMap->find(fullName);
1693 if (ndi) // existing namespace
1694 {
1696 if (nd) // non-inline namespace
1697 {
1698 AUTO_TRACE_ADD("Existing namespace");
1699 nd->setDocumentation(root->doc,root->docFile,root->docLine);
1700 nd->setName(fullName); // change name to match docs
1702 nd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1703 if (nd->getLanguage()==SrcLangExt::Unknown)
1704 {
1705 nd->setLanguage(root->lang);
1706 }
1707 if (root->tagInfo()==nullptr && nd->isReference() && !(root->doc.isEmpty() && root->brief.isEmpty()))
1708 // if we previously found namespace nd in a tag file and now we find a
1709 // documented namespace with the same name in the project, then remove
1710 // the tag file reference
1711 {
1712 nd->setReference("");
1713 nd->setFileName(fullName);
1714 }
1715 nd->setMetaData(root->metaData);
1716
1717 // file definition containing the namespace nd
1718 FileDef *fd=root->fileDef();
1719 if (nd->isArtificial())
1720 {
1721 nd->setArtificial(FALSE); // found namespace explicitly, so cannot be artificial
1722 nd->setDefFile(root->fileName,root->startLine,root->startColumn);
1723 }
1724 // insert the namespace in the file definition
1725 if (fd) fd->insertNamespace(nd);
1726 addNamespaceToGroups(root,nd);
1727 nd->setRefItems(root->sli);
1728 }
1729 }
1730 else // fresh namespace
1731 {
1732 QCString tagName;
1733 QCString tagFileName;
1734 const TagInfo *tagInfo = root->tagInfo();
1735 if (tagInfo)
1736 {
1737 tagName = tagInfo->tagName;
1738 tagFileName = tagInfo->fileName;
1739 }
1740 AUTO_TRACE_ADD("new namespace {} lang={} tagName={}",fullName,langToString(root->lang),tagName);
1741 // add namespace to the list
1743 Doxygen::namespaceLinkedMap->add(fullName,
1744 createNamespaceDef(tagInfo?tagName:root->fileName,root->startLine,
1745 root->startColumn,fullName,tagName,tagFileName,
1746 root->type,root->spec.isPublished())));
1747 if (nd)
1748 {
1749 nd->setDocumentation(root->doc,root->docFile,root->docLine); // copy docs to definition
1750 nd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1752 nd->setHidden(root->hidden);
1753 nd->setArtificial(root->artificial);
1754 nd->setLanguage(root->lang);
1755 nd->setId(root->id);
1756 nd->setMetaData(root->metaData);
1757 nd->setInline(root->spec.isInline());
1758 nd->setExported(root->exported);
1759
1760 addNamespaceToGroups(root,nd);
1761 nd->setRefItems(root->sli);
1762
1763 // file definition containing the namespace nd
1764 FileDef *fd=root->fileDef();
1765 // insert the namespace in the file definition
1766 if (fd) fd->insertNamespace(nd);
1767
1768 // the empty string test is needed for extract all case
1769 nd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1770 nd->insertUsedFile(fd);
1771 nd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
1772 nd->setBodyDef(fd);
1773
1774 // also add namespace to the correct structural context
1775 Definition *d = findScopeFromQualifiedName(Doxygen::globalScope,fullName,nullptr,tagInfo);
1776 AUTO_TRACE_ADD("adding namespace {} to context {}",nd->name(),d ? d->name() : QCString("<none>"));
1777 if (d==nullptr) // we didn't find anything, create the scope artificially
1778 // anyway, so we can at least relate scopes properly.
1779 {
1780 d = buildScopeFromQualifiedName(fullName,nd->getLanguage(),tagInfo);
1782 if (dm)
1783 {
1784 dm->addInnerCompound(nd);
1785 }
1786 nd->setOuterScope(d);
1787 // TODO: Due to the order in which the tag file is written
1788 // a nested class can be found before its parent!
1789 }
1790 else
1791 {
1793 if (dm)
1794 {
1795 dm->addInnerCompound(nd);
1796 }
1797 nd->setOuterScope(d);
1798 // in case of d is an inline namespace, alias insert nd in the part scope of d.
1800 {
1801 NamespaceDef *pnd = toNamespaceDef(d);
1802 if (pnd && pnd->isInline())
1803 {
1804 d = d->getOuterScope();
1805 if (d)
1806 {
1807 dm = toDefinitionMutable(d);
1808 if (dm)
1809 {
1810 auto aliasNd = createNamespaceDefAlias(d,nd);
1811 dm->addInnerCompound(aliasNd.get());
1812 QCString aliasName = aliasNd->name();
1813 AUTO_TRACE_ADD("adding alias {} to {}",aliasName,d->name());
1814 Doxygen::namespaceLinkedMap->add(aliasName,std::move(aliasNd));
1815 }
1816 }
1817 else
1818 {
1819 break;
1820 }
1821 }
1822 else
1823 {
1824 break;
1825 }
1826 }
1827 }
1828 }
1829 }
1830 }
1831 }
1832 for (const auto &e : root->children()) buildNamespaceList(e.get());
1833}
1834
1835//----------------------------------------------------------------------
1836
1838 const QCString &name)
1839{
1840 NamespaceDef *usingNd =nullptr;
1841 for (auto &und : unl)
1842 {
1843 QCString uScope=und->name()+"::";
1844 usingNd = getResolvedNamespace(uScope+name);
1845 if (usingNd!=nullptr) break;
1846 }
1847 return usingNd;
1848}
1849
1850static void findUsingDirectives(const Entry *root)
1851{
1852 if (root->section.isUsingDir())
1853 {
1854 AUTO_TRACE("Found using directive {} at line {} of {}",root->name,root->startLine,root->fileName);
1855 QCString name=substitute(root->name,".","::");
1856 if (name.endsWith("::"))
1857 {
1858 name=name.left(name.length()-2);
1859 }
1860 if (!name.isEmpty())
1861 {
1862 NamespaceDef *usingNd = nullptr;
1863 NamespaceDefMutable *nd = nullptr;
1864 FileDef *fd = root->fileDef();
1865 QCString nsName;
1866
1867 // see if the using statement was found inside a namespace or inside
1868 // the global file scope.
1869 if (root->parent() && root->parent()->section.isNamespace() &&
1870 (fd==nullptr || fd->getLanguage()!=SrcLangExt::Java) // not a .java file
1871 )
1872 {
1873 nsName=stripAnonymousNamespaceScope(root->parent()->name);
1874 if (!nsName.isEmpty())
1875 {
1876 nd = getResolvedNamespaceMutable(nsName);
1877 }
1878 }
1879
1880 // find the scope in which the 'using' namespace is defined by prepending
1881 // the possible scopes in which the using statement was found, starting
1882 // with the most inner scope and going to the most outer scope (i.e.
1883 // file scope).
1884 int scopeOffset = static_cast<int>(nsName.length());
1885 do
1886 {
1887 QCString scope=scopeOffset>0 ?
1888 nsName.left(scopeOffset)+"::" : QCString();
1889 usingNd = getResolvedNamespace(scope+name);
1890 //printf("Trying with scope='%s' usingNd=%p\n",(scope+qPrint(name)),usingNd);
1891 if (scopeOffset==0)
1892 {
1893 scopeOffset=-1;
1894 }
1895 else if ((scopeOffset=nsName.findRev("::",scopeOffset-1))==-1)
1896 {
1897 scopeOffset=0;
1898 }
1899 } while (scopeOffset>=0 && usingNd==nullptr);
1900
1901 if (usingNd==nullptr && nd) // not found, try used namespaces in this scope
1902 // or in one of the parent namespace scopes
1903 {
1904 const NamespaceDefMutable *pnd = nd;
1905 while (pnd && usingNd==nullptr)
1906 {
1907 // also try with one of the used namespaces found earlier
1909
1910 // goto the parent
1911 Definition *s = pnd->getOuterScope();
1912 if (s && s->definitionType()==Definition::TypeNamespace)
1913 {
1915 }
1916 else
1917 {
1918 pnd = nullptr;
1919 }
1920 }
1921 }
1922 if (usingNd==nullptr && fd) // still nothing, also try used namespace in the
1923 // global scope
1924 {
1925 usingNd = findUsedNamespace(fd->getUsedNamespaces(),name);
1926 }
1927
1928 //printf("%s -> %s\n",qPrint(name),usingNd?qPrint(usingNd->name()):"<none>");
1929
1930 // add the namespace the correct scope
1931 if (usingNd)
1932 {
1933 //printf("using fd=%p nd=%p\n",fd,nd);
1934 if (nd)
1935 {
1936 //printf("Inside namespace %s\n",qPrint(nd->name()));
1937 nd->addUsingDirective(usingNd);
1938 }
1939 else if (fd)
1940 {
1941 //printf("Inside file %s\n",qPrint(fd->name()));
1942 fd->addUsingDirective(usingNd);
1943 }
1944 }
1945 else // unknown namespace, but add it anyway.
1946 {
1947 AUTO_TRACE_ADD("new unknown namespace {} lang={} hidden={}",name,langToString(root->lang),root->hidden);
1948 // add namespace to the list
1951 createNamespaceDef(root->fileName,root->startLine,root->startColumn,name)));
1952 if (nd)
1953 {
1954 nd->setDocumentation(root->doc,root->docFile,root->docLine); // copy docs to definition
1955 nd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1957 nd->setHidden(root->hidden);
1958 nd->setArtificial(TRUE);
1959 nd->setLanguage(root->lang);
1960 nd->setId(root->id);
1961 nd->setMetaData(root->metaData);
1962 nd->setInline(root->spec.isInline());
1963 nd->setExported(root->exported);
1964
1965 for (const Grouping &g : root->groups)
1966 {
1967 GroupDef *gd=nullptr;
1968 if (!g.groupname.isEmpty() && (gd=Doxygen::groupLinkedMap->find(g.groupname)))
1969 gd->addNamespace(nd);
1970 }
1971
1972 // insert the namespace in the file definition
1973 if (fd)
1974 {
1975 fd->insertNamespace(nd);
1976 fd->addUsingDirective(nd);
1977 }
1978
1979 // the empty string test is needed for extract all case
1980 nd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
1981 nd->insertUsedFile(fd);
1982 nd->setRefItems(root->sli);
1983 }
1984 }
1985 }
1986 }
1987 for (const auto &e : root->children()) findUsingDirectives(e.get());
1988}
1989
1990//----------------------------------------------------------------------
1991
1992static void buildListOfUsingDecls(const Entry *root)
1993{
1994 if (root->section.isUsingDecl() &&
1995 !root->parent()->section.isCompound() // not a class/struct member
1996 )
1997 {
1998 QCString name = substitute(root->name,".","::");
1999 g_usingDeclarations.insert(name.str());
2000 }
2001 for (const auto &e : root->children()) buildListOfUsingDecls(e.get());
2002}
2003
2004
2005static void findUsingDeclarations(const Entry *root,bool filterPythonPackages)
2006{
2007 if (root->section.isUsingDecl() &&
2008 !root->parent()->section.isCompound() && // not a class/struct member
2009 (!filterPythonPackages || (root->lang==SrcLangExt::Python && root->fileName.endsWith("__init__.py")))
2010 )
2011 {
2012 AUTO_TRACE("Found using declaration '{}' at line {} of {} inside section {}",
2013 root->name,root->startLine,root->fileName,root->parent()->section);
2014 if (!root->name.isEmpty())
2015 {
2016 const Definition *usingDef = nullptr;
2017 NamespaceDefMutable *nd = nullptr;
2018 FileDef *fd = root->fileDef();
2019 QCString scName;
2020
2021 // see if the using statement was found inside a namespace or inside
2022 // the global file scope.
2023 if (root->parent()->section.isNamespace())
2024 {
2025 scName=root->parent()->name;
2026 if (!scName.isEmpty())
2027 {
2028 nd = getResolvedNamespaceMutable(scName);
2029 }
2030 }
2031
2032 // Assume the using statement was used to import a class.
2033 // Find the scope in which the 'using' namespace is defined by prepending
2034 // the possible scopes in which the using statement was found, starting
2035 // with the most inner scope and going to the most outer scope (i.e.
2036 // file scope).
2037
2038 QCString name = substitute(root->name,".","::"); //Java/C# scope->internal
2039
2040 SymbolResolver resolver;
2041 const Definition *scope = nd;
2042 if (nd==nullptr) scope = fd;
2043 usingDef = resolver.resolveSymbol(scope,name);
2044
2045 //printf("usingDef(scope=%s,name=%s)=%s\n",qPrint(nd?nd->qualifiedName():""),qPrint(name),usingDef?qPrint(usingDef->qualifiedName()):"nullptr");
2046
2047 if (!usingDef)
2048 {
2049 usingDef = getClass(name); // try direct lookup, this is needed to get
2050 // builtin STL classes to properly resolve, e.g.
2051 // vector -> std::vector
2052 }
2053 if (!usingDef)
2054 {
2055 usingDef = Doxygen::hiddenClassLinkedMap->find(name); // check if it is already hidden
2056 }
2057#if 0
2058 if (!usingDef)
2059 {
2060 AUTO_TRACE_ADD("New using class '{}' (sec={})! #tArgLists={}",
2061 name,root->section,root->tArgLists.size());
2064 createClassDef( "<using>",1,1, name, ClassDef::Class)));
2065 if (usingCd)
2066 {
2067 usingCd->setArtificial(TRUE);
2068 usingCd->setLanguage(root->lang);
2069 usingDef = usingCd;
2070 }
2071 }
2072#endif
2073 else
2074 {
2075 AUTO_TRACE_ADD("Found used type '{}' in scope='{}'",
2076 usingDef->name(), nd ? nd->name(): fd ? fd->name() : QCString("<unknown>"));
2077 }
2078
2079 if (usingDef)
2080 {
2081 if (nd)
2082 {
2083 nd->addUsingDeclaration(usingDef);
2084 }
2085 else if (fd)
2086 {
2087 fd->addUsingDeclaration(usingDef);
2088 }
2089 }
2090 }
2091 }
2092 for (const auto &e : root->children()) findUsingDeclarations(e.get(),filterPythonPackages);
2093}
2094
2095//----------------------------------------------------------------------
2096
2098{
2099 root->commandOverrides.apply_callGraph ([&](bool b) { md->overrideCallGraph(b); });
2100 root->commandOverrides.apply_callerGraph ([&](bool b) { md->overrideCallerGraph(b); });
2101 root->commandOverrides.apply_referencedByRelation([&](bool b) { md->overrideReferencedByRelation(b); });
2102 root->commandOverrides.apply_referencesRelation ([&](bool b) { md->overrideReferencesRelation(b); });
2103 root->commandOverrides.apply_inlineSource ([&](bool b) { md->overrideInlineSource(b); });
2104 root->commandOverrides.apply_enumValues ([&](bool b) { md->overrideEnumValues(b); });
2105}
2106
2107//----------------------------------------------------------------------
2108
2110 const QCString &fileName,const QCString &memName)
2111{
2112 AUTO_TRACE("creating new member {} for class {}",memName,cd->name());
2113 const ArgumentList &templAl = md->templateArguments();
2114 const ArgumentList &al = md->argumentList();
2115 auto newMd = createMemberDef(
2116 fileName,root->startLine,root->startColumn,
2117 md->typeString(),memName,md->argsString(),
2118 md->excpString(),root->protection,root->virt,
2119 md->isStatic(),Relationship::Member,md->memberType(),
2120 templAl,al,root->metaData
2121 );
2122 auto newMmd = toMemberDefMutable(newMd.get());
2123 newMmd->setMemberClass(cd);
2124 cd->insertMember(newMd.get());
2125 if (!root->doc.isEmpty() || !root->brief.isEmpty())
2126 {
2127 newMmd->setDocumentation(root->doc,root->docFile,root->docLine);
2128 newMmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
2129 newMmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
2130 }
2131 else
2132 {
2133 newMmd->setDocumentation(md->documentation(),md->docFile(),md->docLine());
2134 newMmd->setBriefDescription(md->briefDescription(),md->briefFile(),md->briefLine());
2135 newMmd->setInbodyDocumentation(md->inbodyDocumentation(),md->inbodyFile(),md->inbodyLine());
2136 }
2137 newMmd->setDefinition(md->definition());
2138 applyMemberOverrideOptions(root,newMmd);
2139 newMmd->addQualifiers(root->qualifiers);
2140 newMmd->setBitfields(md->bitfieldString());
2141 newMmd->addSectionsToDefinition(root->anchors);
2142 newMmd->setBodySegment(md->getDefLine(),md->getStartBodyLine(),md->getEndBodyLine());
2143 newMmd->setBodyDef(md->getBodyDef());
2144 newMmd->setInitializer(md->initializer());
2145 newMmd->setRequiresClause(md->requiresClause());
2146 newMmd->setMaxInitLines(md->initializerLines());
2147 newMmd->setMemberGroupId(root->mGrpId);
2148 newMmd->setMemberSpecifiers(md->getMemberSpecifiers());
2149 newMmd->setVhdlSpecifiers(md->getVhdlSpecifiers());
2150 newMmd->setLanguage(root->lang);
2151 newMmd->setId(root->id);
2152 MemberName *mn = Doxygen::memberNameLinkedMap->add(memName);
2153 mn->push_back(std::move(newMd));
2154}
2155
2156static std::unordered_map<std::string,std::vector<ClassDefMutable*>> g_usingClassMap;
2157
2158static void findUsingDeclImports(const Entry *root)
2159{
2160 if (root->section.isUsingDecl() &&
2161 root->parent()->section.isCompound() // in a class/struct member
2162 )
2163 {
2164 AUTO_TRACE("Found using declaration '{}' inside section {}", root->name, root->parent()->section);
2165 QCString fullName=removeRedundantWhiteSpace(root->parent()->name);
2166 fullName=stripAnonymousNamespaceScope(fullName);
2167 fullName=stripTemplateSpecifiersFromScope(fullName);
2168 ClassDefMutable *cd = getClassMutable(fullName);
2169 if (cd)
2170 {
2171 AUTO_TRACE_ADD("found class '{}'",cd->name());
2172 int i=root->name.findRev("::");
2173 if (i!=-1)
2174 {
2175 QCString scope=root->name.left(i);
2176 QCString memName=root->name.right(root->name.length()-i-2);
2177 SymbolResolver resolver;
2178 const ClassDef *bcd = resolver.resolveClass(cd,scope); // todo: file in fileScope parameter
2179 AUTO_TRACE_ADD("name={} scope={} bcd={}",scope,cd?cd->name():"<none>",bcd?bcd->name():"<none>");
2180 if (bcd && bcd!=cd)
2181 {
2182 AUTO_TRACE_ADD("found class '{}' memName='{}'",bcd->name(),memName);
2184 const MemberNameInfo *mni = mnlm.find(memName);
2185 if (mni)
2186 {
2187 for (auto &mi : *mni)
2188 {
2189 const MemberDef *md = mi->memberDef();
2190 if (md && md->protection()!=Protection::Private)
2191 {
2192 AUTO_TRACE_ADD("found member '{}'",mni->memberName());
2193 QCString fileName = root->fileName;
2194 if (fileName.isEmpty() && root->tagInfo())
2195 {
2196 fileName = root->tagInfo()->tagName;
2197 }
2198 if (!cd->containsOverload(md))
2199 {
2200 createUsingMemberImportForClass(root,cd,md,fileName,memName);
2201 // also insert the member into copies of the class
2202 auto it = g_usingClassMap.find(cd->qualifiedName().str());
2203 if (it != g_usingClassMap.end())
2204 {
2205 for (const auto &copyCd : it->second)
2206 {
2207 createUsingMemberImportForClass(root,copyCd,md,fileName,memName);
2208 }
2209 }
2210 }
2211 }
2212 }
2213 }
2214 }
2215 }
2216 }
2217 }
2218 else if (root->section.isUsingDecl() &&
2219 (root->parent()->section.isNamespace() || root->parent()->section.isEmpty()) && // namespace or global member
2220 root->lang==SrcLangExt::Cpp // do we also want this for e.g. Fortran? (see test case 095)
2221 )
2222 {
2223 AUTO_TRACE("Found using declaration '{}' inside section {}", root->name, root->parent()->section);
2224 Definition *scope = nullptr;
2225 NamespaceDefMutable *nd = nullptr;
2226 FileDef *fd = root->parent()->fileDef();
2227 if (!root->parent()->name.isEmpty())
2228 {
2229 QCString fullName=removeRedundantWhiteSpace(root->parent()->name);
2230 fullName=stripAnonymousNamespaceScope(fullName);
2232 scope = nd;
2233 }
2234 else
2235 {
2236 scope = fd;
2237 }
2238 if (scope)
2239 {
2240 AUTO_TRACE_ADD("found scope '{}'",scope->name());
2241 SymbolResolver resolver;
2242 const Definition *def = resolver.resolveSymbol(root->name.startsWith("::") ? nullptr : scope,root->name);
2243 if (def && def->definitionType()==Definition::TypeMember)
2244 {
2245 int i=root->name.findRev("::");
2246 QCString memName;
2247 if (i!=-1)
2248 {
2249 memName = root->name.right(root->name.length()-i-2);
2250 }
2251 else
2252 {
2253 memName = root->name;
2254 }
2255 const MemberDef *md = toMemberDef(def);
2256 AUTO_TRACE_ADD("found member '{}' for name '{}'",md->qualifiedName(),root->name);
2257 QCString fileName = root->fileName;
2258 if (fileName.isEmpty() && root->tagInfo())
2259 {
2260 fileName = root->tagInfo()->tagName;
2261 }
2262 const ArgumentList &templAl = md->templateArguments();
2263 const ArgumentList &al = md->argumentList();
2264
2265 auto newMd = createMemberDef(
2266 fileName,root->startLine,root->startColumn,
2267 md->typeString(),memName,md->argsString(),
2268 md->excpString(),root->protection,root->virt,
2269 md->isStatic(),Relationship::Member,md->memberType(),
2270 templAl,al,root->metaData
2271 );
2272 auto newMmd = toMemberDefMutable(newMd.get());
2273 if (nd)
2274 {
2275 newMmd->setNamespace(nd);
2276 nd->insertMember(newMd.get());
2277 }
2278 if (fd)
2279 {
2280 newMmd->setFileDef(fd);
2281 fd->insertMember(newMd.get());
2282 }
2283 if (!root->doc.isEmpty() || !root->brief.isEmpty())
2284 {
2285 newMmd->setDocumentation(root->doc,root->docFile,root->docLine);
2286 newMmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
2287 newMmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
2288 }
2289 else
2290 {
2291 newMmd->setDocumentation(md->documentation(),md->docFile(),md->docLine());
2292 newMmd->setBriefDescription(md->briefDescription(),md->briefFile(),md->briefLine());
2293 newMmd->setInbodyDocumentation(md->inbodyDocumentation(),md->inbodyFile(),md->inbodyLine());
2294 }
2295 newMmd->setDefinition(md->definition());
2296 applyMemberOverrideOptions(root,newMmd);
2297 newMmd->addQualifiers(root->qualifiers);
2298 newMmd->setBitfields(md->bitfieldString());
2299 newMmd->addSectionsToDefinition(root->anchors);
2300 newMmd->setBodySegment(md->getDefLine(),md->getStartBodyLine(),md->getEndBodyLine());
2301 newMmd->setBodyDef(md->getBodyDef());
2302 newMmd->setInitializer(md->initializer());
2303 newMmd->setRequiresClause(md->requiresClause());
2304 newMmd->setMaxInitLines(md->initializerLines());
2305 newMmd->setMemberGroupId(root->mGrpId);
2306 newMmd->setMemberSpecifiers(md->getMemberSpecifiers());
2307 newMmd->setVhdlSpecifiers(md->getVhdlSpecifiers());
2308 newMmd->setLanguage(root->lang);
2309 newMmd->setId(root->id);
2310 MemberName *mn = Doxygen::functionNameLinkedMap->add(memName);
2311 mn->push_back(std::move(newMd));
2312#if 0 // insert an alias instead of a copy
2313 const MemberDef *md = toMemberDef(def);
2314 AUTO_TRACE_ADD("found member '{}' for name '{}'",md->qualifiedName(),root->name);
2315 auto aliasMd = createMemberDefAlias(nd,md);
2316 QCString aliasFullName = nd->qualifiedName()+"::"+aliasMd->localName();
2317 if (nd && aliasMd.get())
2318 {
2319 nd->insertMember(aliasMd.get());
2320 }
2321 if (fd && aliasMd.get())
2322 {
2323 fd->insertMember(aliasMd.get());
2324 }
2325 MemberName *mn = Doxygen::memberNameLinkedMap->add(aliasFullName);
2326 mn->push_back(std::move(aliasMd));
2327#endif
2328 }
2329 else if (def && def->definitionType()==Definition::TypeClass)
2330 {
2331 const ClassDef *cd = toClassDef(def);
2332 QCString copyFullName;
2333 if (nd==nullptr)
2334 {
2335 copyFullName = cd->localName();
2336 }
2337 else
2338 {
2339 copyFullName = nd->qualifiedName()+"::"+cd->localName();
2340 }
2341 if (Doxygen::classLinkedMap->find(copyFullName)==nullptr)
2342 {
2344 Doxygen::classLinkedMap->add(copyFullName,
2345 cd->deepCopy(copyFullName)));
2346 AUTO_TRACE_ADD("found class '{}' for name '{}' copy '{}' obj={}",cd->qualifiedName(),root->name,copyFullName,(void*)ncdm);
2347 g_usingClassMap[cd->qualifiedName().str()].push_back(ncdm);
2348 if (ncdm)
2349 {
2350 if (nd) ncdm->moveTo(nd);
2351 if ((!root->doc.isEmpty() || !root->brief.isEmpty())) // use docs at using statement
2352 {
2353 ncdm->setDocumentation(root->doc,root->docFile,root->docLine);
2354 ncdm->setBriefDescription(root->brief,root->briefFile,root->briefLine);
2355 }
2356 else // use docs from used class
2357 {
2358 ncdm->setDocumentation(cd->documentation(),cd->docFile(),cd->docLine());
2360 }
2361 if (nd)
2362 {
2363 nd->addInnerCompound(ncdm);
2364 nd->addUsingDeclaration(ncdm);
2365 }
2366 if (fd)
2367 {
2368 if (ncdm) ncdm->setFileDef(fd);
2369 fd->insertClass(ncdm);
2370 fd->addUsingDeclaration(ncdm);
2371 }
2372 }
2373 }
2374#if 0 // insert an alias instead of a copy
2375 auto aliasCd = createClassDefAlias(nd,cd);
2376 QCString aliasFullName;
2377 if (nd==nullptr)
2378 {
2379 aliasFullName = aliasCd->localName();
2380 }
2381 else
2382 {
2383 aliasFullName = nd->qualifiedName()+"::"+aliasCd->localName();
2384 }
2385 AUTO_TRACE_ADD("found class '{}' for name '{}' aliasFullName='{}'",cd->qualifiedName(),root->name,aliasFullName);
2386 auto acd = Doxygen::classLinkedMap->add(aliasFullName,std::move(aliasCd));
2387 if (nd && acd)
2388 {
2389 nd->addInnerCompound(acd);
2390 }
2391 if (fd && acd)
2392 {
2393 fd->insertClass(acd);
2394 }
2395#endif
2396 }
2397 else if (scope)
2398 {
2399 AUTO_TRACE_ADD("no symbol with name '{}' in scope {}",root->name,scope->name());
2400 }
2401 }
2402 }
2403 for (const auto &e : root->children()) findUsingDeclImports(e.get());
2404}
2405
2406//----------------------------------------------------------------------
2407
2409{
2410 FileDefSet visitedFiles;
2411 // then recursively add using directives found in #include files
2412 // to files that have not been visited.
2413 for (const auto &fn : *Doxygen::inputNameLinkedMap)
2414 {
2415 for (const auto &fd : *fn)
2416 {
2417 //printf("----- adding using directives for file %s\n",qPrint(fd->name()));
2418 fd->addIncludedUsingDirectives(visitedFiles);
2419 }
2420 }
2421}
2422
2423//----------------------------------------------------------------------
2424
2426 const Entry *root,
2427 ClassDefMutable *cd,
2428 MemberType mtype,
2429 const QCString &type,
2430 const QCString &name,
2431 const QCString &args,
2432 bool fromAnnScope,
2433 MemberDef *fromAnnMemb,
2434 Protection prot,
2435 Relationship related)
2436{
2438 QCString scopeSeparator="::";
2439 SrcLangExt lang = cd->getLanguage();
2440 if (lang==SrcLangExt::Java || lang==SrcLangExt::CSharp)
2441 {
2442 qualScope = substitute(qualScope,"::",".");
2443 scopeSeparator=".";
2444 }
2445 AUTO_TRACE("class variable: file='{}' type='{}' scope='{}' name='{}' args='{}' prot={} mtype={} lang={} ann={} init='{}'",
2446 root->fileName, type, qualScope, name, args, root->protection, mtype, lang, fromAnnScope, root->initializer.str());
2447
2448 QCString def;
2449 if (!type.isEmpty())
2450 {
2451 if (related!=Relationship::Member || mtype==MemberType::Friend || Config_getBool(HIDE_SCOPE_NAMES))
2452 {
2453 if (root->spec.isAlias()) // turn 'typedef B A' into 'using A'
2454 {
2455 def="using "+name;
2456 }
2457 else
2458 {
2459 def=type+" "+name+args;
2460 }
2461 }
2462 else
2463 {
2464 if (root->spec.isAlias()) // turn 'typedef B C::A' into 'using C::A'
2465 {
2466 def="using "+qualScope+scopeSeparator+name;
2467 }
2468 else
2469 {
2470 def=type+" "+qualScope+scopeSeparator+name+args;
2471 }
2472 }
2473 }
2474 else
2475 {
2476 if (Config_getBool(HIDE_SCOPE_NAMES))
2477 {
2478 def=name+args;
2479 }
2480 else
2481 {
2482 def=qualScope+scopeSeparator+name+args;
2483 }
2484 }
2485 def.stripPrefix("static ");
2486
2487 // see if the member is already found in the same scope
2488 // (this may be the case for a static member that is initialized
2489 // outside the class)
2491 if (mn)
2492 {
2493 for (const auto &imd : *mn)
2494 {
2495 //printf("md->getClassDef()=%p cd=%p type=[%s] md->typeString()=[%s]\n",
2496 // md->getClassDef(),cd,qPrint(type),md->typeString());
2497 MemberDefMutable *md = toMemberDefMutable(imd.get());
2498 if (md &&
2499 md->getClassDef()==cd &&
2500 ((lang==SrcLangExt::Python && type.isEmpty() && !md->typeString().isEmpty()) ||
2502 // member already in the scope
2503 {
2504
2505 if (root->lang==SrcLangExt::ObjC &&
2506 root->mtype==MethodTypes::Property &&
2508 { // Objective-C 2.0 property
2509 // turn variable into a property
2510 md->setProtection(root->protection);
2512 }
2513 addMemberDocs(root,md,def,nullptr,FALSE,root->spec);
2514 AUTO_TRACE_ADD("Member already found!");
2515 return md;
2516 }
2517 }
2518 }
2519
2520 QCString fileName = root->fileName;
2521 if (fileName.isEmpty() && root->tagInfo())
2522 {
2523 fileName = root->tagInfo()->tagName;
2524 }
2525
2526 // new member variable, typedef or enum value
2527 auto md = createMemberDef(
2528 fileName,root->startLine,root->startColumn,
2529 type,name,args,root->exception,
2530 prot,Specifier::Normal,root->isStatic,related,
2531 mtype,!root->tArgLists.empty() ? root->tArgLists.back() : ArgumentList(),
2532 ArgumentList(), root->metaData);
2533 auto mmd = toMemberDefMutable(md.get());
2534 mmd->setTagInfo(root->tagInfo());
2535 mmd->setMemberClass(cd); // also sets outer scope (i.e. getOuterScope())
2536 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
2537 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
2538 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
2539 mmd->setDefinition(def);
2540 mmd->setBitfields(root->bitfields);
2541 mmd->addSectionsToDefinition(root->anchors);
2542 mmd->setFromAnonymousScope(fromAnnScope);
2543 mmd->setFromAnonymousMember(fromAnnMemb);
2544 //md->setIndentDepth(indentDepth);
2545 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
2546 std::string init = root->initializer.str();
2547 mmd->setInitializer(init.c_str());
2548 mmd->setMaxInitLines(root->initLines);
2549 mmd->setMemberGroupId(root->mGrpId);
2550 mmd->setMemberSpecifiers(root->spec);
2551 mmd->setVhdlSpecifiers(root->vhdlSpec);
2552 mmd->setReadAccessor(root->read);
2553 mmd->setWriteAccessor(root->write);
2555 mmd->setHidden(root->hidden);
2556 mmd->setArtificial(root->artificial);
2557 mmd->setLanguage(root->lang);
2558 mmd->setId(root->id);
2559 addMemberToGroups(root,md.get());
2561 mmd->setBodyDef(root->fileDef());
2562 mmd->addQualifiers(root->qualifiers);
2563
2564 AUTO_TRACE_ADD("Adding new member to class '{}'",cd->name());
2565 cd->insertMember(md.get());
2566 mmd->setRefItems(root->sli);
2567
2568 cd->insertUsedFile(root->fileDef());
2569 root->markAsProcessed();
2570
2571 if (mtype==MemberType::Typedef)
2572 {
2573 resolveTemplateInstanceInType(root,cd,md.get());
2574 }
2575
2576 // add the member to the global list
2577 MemberDef *result = md.get();
2578 mn = Doxygen::memberNameLinkedMap->add(name);
2579 mn->push_back(std::move(md));
2580
2581 return result;
2582}
2583
2584//----------------------------------------------------------------------
2585
2587 const Entry *root,
2588 MemberType mtype,
2589 const QCString &scope,
2590 const QCString &type,
2591 const QCString &name,
2592 const QCString &args,
2593 bool fromAnnScope,
2594 MemberDef *fromAnnMemb)
2595{
2596 AUTO_TRACE("global variable: file='{}' type='{}' scope='{}' name='{}' args='{}' prot={} mtype={} lang={} init='{}'",
2597 root->fileName, type, scope, name, args, root->protection, mtype, root->lang, root->initializer.str());
2598
2599 FileDef *fd = root->fileDef();
2600
2601 // see if we have a typedef that should hide a struct or union
2602 if (mtype==MemberType::Typedef && Config_getBool(TYPEDEF_HIDES_STRUCT))
2603 {
2604 QCString ttype = type;
2605 ttype.stripPrefix("typedef ");
2606 if (ttype.stripPrefix("struct ") || ttype.stripPrefix("union "))
2607 {
2608 static const reg::Ex re(R"(\a\w*)");
2609 reg::Match match;
2610 std::string typ = ttype.str();
2611 if (reg::search(typ,match,re))
2612 {
2613 QCString typeValue = match.str();
2614 ClassDefMutable *cd = getClassMutable(typeValue);
2615 if (cd)
2616 {
2617 // this typedef should hide compound name cd, so we
2618 // change the name that is displayed from cd.
2619 cd->setClassName(name);
2620 cd->setDocumentation(root->doc,root->docFile,root->docLine);
2621 cd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
2622 return nullptr;
2623 }
2624 }
2625 }
2626 }
2627
2628 // see if the function is inside a namespace
2629 NamespaceDefMutable *nd = nullptr;
2630 if (!scope.isEmpty())
2631 {
2632 if (scope.find('@')!=-1) return nullptr; // anonymous scope!
2633 nd = getResolvedNamespaceMutable(scope);
2634 }
2635 QCString def;
2636
2637 // determine the definition of the global variable
2638 if (nd && !nd->isAnonymous() &&
2639 !Config_getBool(HIDE_SCOPE_NAMES)
2640 )
2641 // variable is inside a namespace, so put the scope before the name
2642 {
2643 SrcLangExt lang = nd->getLanguage();
2645
2646 if (!type.isEmpty())
2647 {
2648 if (root->spec.isAlias()) // turn 'typedef B NS::A' into 'using NS::A'
2649 {
2650 def="using "+nd->name()+sep+name;
2651 }
2652 else // normal member
2653 {
2654 def=type+" "+nd->name()+sep+name+args;
2655 }
2656 }
2657 else
2658 {
2659 def=nd->name()+sep+name+args;
2660 }
2661 }
2662 else
2663 {
2664 if (!type.isEmpty() && !root->name.isEmpty())
2665 {
2666 if (name.at(0)=='@') // dummy variable representing anonymous union
2667 {
2668 def=type;
2669 }
2670 else
2671 {
2672 if (root->spec.isAlias()) // turn 'typedef B A' into 'using A'
2673 {
2674 def="using "+root->name;
2675 }
2676 else // normal member
2677 {
2678 def=type+" "+name+args;
2679 }
2680 }
2681 }
2682 else
2683 {
2684 def=name+args;
2685 }
2686 }
2687 def.stripPrefix("static ");
2688
2690 if (mn)
2691 {
2692 //QCString nscope=removeAnonymousScopes(scope);
2693 //NamespaceDef *nd=nullptr;
2694 //if (!nscope.isEmpty())
2695 if (!scope.isEmpty())
2696 {
2697 nd = getResolvedNamespaceMutable(scope);
2698 }
2699 for (const auto &imd : *mn)
2700 {
2701 MemberDefMutable *md = toMemberDefMutable(imd.get());
2702 if (md &&
2703 ((nd==nullptr && md->getNamespaceDef()==nullptr && md->getFileDef() &&
2704 root->fileName==md->getFileDef()->absFilePath()
2705 ) // both variable names in the same file
2706 || (nd!=nullptr && md->getNamespaceDef()==nd) // both in same namespace
2707 )
2708 && !md->isDefine() // function style #define's can be "overloaded" by typedefs or variables
2709 && !md->isEnumerate() // in C# an enum value and enum can have the same name
2710 )
2711 // variable already in the scope
2712 {
2713 bool isPHPArray = md->getLanguage()==SrcLangExt::PHP &&
2714 md->argsString()!=args &&
2715 args.find('[')!=-1;
2716 bool staticsInDifferentFiles =
2717 root->isStatic && md->isStatic() &&
2718 root->fileName!=md->getDefFileName();
2719
2720 if (md->getFileDef() &&
2721 !isPHPArray && // not a php array
2722 !staticsInDifferentFiles
2723 )
2724 // not a php array variable
2725 {
2726 AUTO_TRACE_ADD("variable already found: scope='{}'",md->getOuterScope()->name());
2727 addMemberDocs(root,md,def,nullptr,FALSE,root->spec);
2728 md->setRefItems(root->sli);
2729 // if md is a variable forward declaration and root is the definition that
2730 // turn md into the definition
2731 if (!root->explicitExternal && md->isExternal())
2732 {
2733 md->setDeclFile(md->getDefFileName(),md->getDefLine(),md->getDefColumn());
2735 }
2736 // if md is the definition and root point at a declaration, then add the
2737 // declaration info
2738 else if (root->explicitExternal && !md->isExternal())
2739 {
2740 md->setDeclFile(root->fileName,root->startLine,root->startColumn);
2741 }
2742 return md;
2743 }
2744 }
2745 }
2746 }
2747
2748 QCString fileName = root->fileName;
2749 if (fileName.isEmpty() && root->tagInfo())
2750 {
2751 fileName = root->tagInfo()->tagName;
2752 }
2753
2754 AUTO_TRACE_ADD("new variable, namespace='{}'",nd?nd->name():QCString("<global>"));
2755 // new global variable, enum value or typedef
2756 auto md = createMemberDef(
2757 fileName,root->startLine,root->startColumn,
2758 type,name,args,QCString(),
2759 root->protection, Specifier::Normal,root->isStatic,Relationship::Member,
2760 mtype,!root->tArgLists.empty() ? root->tArgLists.back() : ArgumentList(),
2761 root->argList, root->metaData);
2762 auto mmd = toMemberDefMutable(md.get());
2763 mmd->setTagInfo(root->tagInfo());
2764 mmd->setMemberSpecifiers(root->spec);
2765 mmd->setVhdlSpecifiers(root->vhdlSpec);
2766 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
2767 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
2768 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
2769 mmd->addSectionsToDefinition(root->anchors);
2770 mmd->setFromAnonymousScope(fromAnnScope);
2771 mmd->setFromAnonymousMember(fromAnnMemb);
2772 std::string init = root->initializer.str();
2773 mmd->setInitializer(init.c_str());
2774 mmd->setMaxInitLines(root->initLines);
2775 mmd->setMemberGroupId(root->mGrpId);
2776 mmd->setDefinition(def);
2777 mmd->setLanguage(root->lang);
2778 mmd->setId(root->id);
2780 mmd->setExplicitExternal(root->explicitExternal,fileName,root->startLine,root->startColumn);
2781 mmd->addQualifiers(root->qualifiers);
2782 //md->setOuterScope(fd);
2783 if (!root->explicitExternal)
2784 {
2785 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
2786 mmd->setBodyDef(fd);
2787 }
2788 addMemberToGroups(root,md.get());
2790
2791 mmd->setRefItems(root->sli);
2792 if (nd && !nd->isAnonymous())
2793 {
2794 mmd->setNamespace(nd);
2795 nd->insertMember(md.get());
2796 }
2797
2798 // add member to the file (we do this even if we have already inserted
2799 // it into the namespace.
2800 if (fd)
2801 {
2802 mmd->setFileDef(fd);
2803 fd->insertMember(md.get());
2804 }
2805
2806 root->markAsProcessed();
2807
2808 if (mtype==MemberType::Typedef)
2809 {
2810 resolveTemplateInstanceInType(root,nd,md.get());
2811 }
2812
2813 // add member definition to the list of globals
2814 MemberDef *result = md.get();
2815 mn = Doxygen::functionNameLinkedMap->add(name);
2816 mn->push_back(std::move(md));
2817
2818
2819
2820 return result;
2821}
2822
2823/*! See if the return type string \a type is that of a function pointer
2824 * \returns -1 if this is not a function pointer variable or
2825 * the index at which the closing brace of (...*name) was found.
2826 */
2827static int findFunctionPtr(const std::string &type,SrcLangExt lang, int *pLength=nullptr)
2828{
2829 AUTO_TRACE("type='{}' lang={}",type,lang);
2830 if (lang == SrcLangExt::Fortran || lang == SrcLangExt::VHDL)
2831 {
2832 return -1; // Fortran and VHDL do not have function pointers
2833 }
2834
2835 static const reg::Ex re(R"(\‍([^)]*[*&^][^)]*\))");
2836 reg::Match match;
2837 size_t i=std::string::npos;
2838 size_t l=0;
2839 if (reg::search(type,match,re)) // contains (...*...) or (...&...) or (...^...)
2840 {
2841 i = match.position();
2842 l = match.length();
2843 }
2844 if (i!=std::string::npos)
2845 {
2846 size_t di = type.find("decltype(");
2847 if (di!=std::string::npos && di<i)
2848 {
2849 i = std::string::npos;
2850 }
2851 }
2852 size_t bb=type.find('<');
2853 size_t be=type.rfind('>');
2854 bool templFp = false;
2855 if (be!=std::string::npos) {
2856 size_t cc_ast = type.find("::*");
2857 size_t cc_amp = type.find("::&");
2858 templFp = (cc_ast != std::string::npos && cc_ast>be) || (cc_amp != std::string::npos && cc_amp>be); // hack to find, e.g 'B<X>(A<int>::*)'
2859 }
2860
2861 if (!type.empty() && // return type is non-empty
2862 i!=std::string::npos && // contains (...*...)
2863 type.find("operator")==std::string::npos && // not an operator
2864 (type.find(")(")==std::string::npos || type.find("typedef ")!=std::string::npos) &&
2865 // not a function pointer return type
2866 (!(bb<i && i<be) || templFp) // bug665855: avoid treating "typedef A<void (T*)> type" as a function pointer
2867 )
2868 {
2869 if (pLength) *pLength=static_cast<int>(l);
2870 //printf("findFunctionPtr=%d\n",(int)i);
2871 AUTO_TRACE_EXIT("result={}",i);
2872 return static_cast<int>(i);
2873 }
2874 else
2875 {
2876 //printf("findFunctionPtr=%d\n",-1);
2877 AUTO_TRACE_EXIT("result=-1");
2878 return -1;
2879 }
2880}
2881
2882//--------------------------------------------------------------------------------------
2883
2884/*! Returns TRUE iff \a type is a class within scope \a context.
2885 * Used to detect variable declarations that look like function prototypes.
2886 */
2887static bool isVarWithConstructor(const Entry *root)
2888{
2889 bool result = false;
2890 bool typeIsClass = false;
2891 bool typePtrType = false;
2892 QCString type;
2893 Definition *ctx = nullptr;
2894 FileDef *fd = root->fileDef();
2895 SymbolResolver resolver(fd);
2896
2897 AUTO_TRACE("isVarWithConstructor({})",root->name);
2898 if (root->parent()->section.isCompound())
2899 { // inside a class
2900 result=FALSE;
2901 AUTO_TRACE_EXIT("inside class: result={}",result);
2902 return result;
2903 }
2904 else if ((fd != nullptr) && (fd->name().endsWith(".c") || fd->name().endsWith(".h")))
2905 { // inside a .c file
2906 result=FALSE;
2907 AUTO_TRACE_EXIT("inside C file: result={}",result);
2908 return result;
2909 }
2910 if (root->type.isEmpty())
2911 {
2912 result=FALSE;
2913 AUTO_TRACE_EXIT("no type: result={}",result);
2914 return result;
2915 }
2916 if (!root->parent()->name.isEmpty())
2917 {
2918 ctx=Doxygen::namespaceLinkedMap->find(root->parent()->name);
2919 }
2920 type = root->type;
2921 // remove qualifiers
2922 findAndRemoveWord(type,"const");
2923 findAndRemoveWord(type,"static");
2924 findAndRemoveWord(type,"volatile");
2925 typePtrType = type.find('*')!=-1 || type.find('&')!=-1;
2926 if (!typePtrType)
2927 {
2928 typeIsClass = resolver.resolveClass(ctx,type)!=nullptr;
2929 int ti=0;
2930 if (!typeIsClass && (ti=type.find('<'))!=-1)
2931 {
2932 typeIsClass=resolver.resolveClass(ctx,type.left(ti))!=nullptr;
2933 }
2934 }
2935 if (typeIsClass) // now we still have to check if the arguments are
2936 // types or values. Since we do not have complete type info
2937 // we need to rely on heuristics :-(
2938 {
2939 if (root->argList.empty())
2940 {
2941 result=FALSE; // empty arg list -> function prototype.
2942 AUTO_TRACE_EXIT("empty arg list: result={}",result);
2943 return result;
2944 }
2945 for (const Argument &a : root->argList)
2946 {
2947 static const reg::Ex initChars(R"([\d"'&*!^]+)");
2948 reg::Match match;
2949 if (!a.name.isEmpty() || !a.defval.isEmpty())
2950 {
2951 std::string name = a.name.str();
2952 if (reg::search(name,match,initChars) && match.position()==0)
2953 {
2954 result=TRUE;
2955 }
2956 else
2957 {
2958 result=FALSE; // arg has (type,name) pair -> function prototype
2959 }
2960 AUTO_TRACE_EXIT("function prototype: result={}",result);
2961 return result;
2962 }
2963 if (!a.type.isEmpty() &&
2964 (a.type.at(a.type.length()-1)=='*' ||
2965 a.type.at(a.type.length()-1)=='&'))
2966 // type ends with * or & => pointer or reference
2967 {
2968 result=FALSE;
2969 AUTO_TRACE_EXIT("pointer or reference: result={}",result);
2970 return result;
2971 }
2972 if (a.type.isEmpty() || resolver.resolveClass(ctx,a.type)!=nullptr)
2973 {
2974 result=FALSE; // arg type is a known type
2975 AUTO_TRACE_EXIT("known type: result={}",result);
2976 return result;
2977 }
2978 if (checkIfTypedef(ctx,fd,a.type))
2979 {
2980 result=FALSE; // argument is a typedef
2981 AUTO_TRACE_EXIT("typedef: result={}",result);
2982 return result;
2983 }
2984 std::string atype = a.type.str();
2985 if (reg::search(atype,match,initChars) && match.position()==0)
2986 {
2987 result=TRUE; // argument type starts with typical initializer char
2988 AUTO_TRACE_EXIT("argument with init char: result={}",result);
2989 return result;
2990 }
2991 std::string resType=resolveTypeDef(ctx,a.type).str();
2992 if (resType.empty()) resType=atype;
2993 static const reg::Ex idChars(R"(\a\w*)");
2994 if (reg::search(resType,match,idChars) && match.position()==0) // resType starts with identifier
2995 {
2996 resType=match.str();
2997 if (resType=="int" || resType=="long" ||
2998 resType=="float" || resType=="double" ||
2999 resType=="char" || resType=="void" ||
3000 resType=="signed" || resType=="unsigned" ||
3001 resType=="const" || resType=="volatile" )
3002 {
3003 result=FALSE; // type keyword -> function prototype
3004 AUTO_TRACE_EXIT("type keyword: result={}",result);
3005 return result;
3006 }
3007 }
3008 }
3009 result=TRUE;
3010 }
3011
3012 AUTO_TRACE_EXIT("end: result={}",result);
3013 return result;
3014}
3015
3016//--------------------------------------------------------------------------------------
3017
3018/*! Searches for the end of a template in prototype \a s starting from
3019 * character position \a startPos. If the end was found the position
3020 * of the closing > is returned, otherwise -1 is returned.
3021 *
3022 * Handles exotic cases such as
3023 * \code
3024 * Class<(id<0)>
3025 * Class<bits<<2>
3026 * Class<"<">
3027 * Class<'<'>
3028 * Class<(")<")>
3029 * \endcode
3030 */
3031static int findEndOfTemplate(const QCString &s,size_t startPos)
3032{
3033 // locate end of template
3034 size_t e=startPos;
3035 int brCount=1;
3036 int roundCount=0;
3037 size_t len = s.length();
3038 bool insideString=FALSE;
3039 bool insideChar=FALSE;
3040 char pc = 0;
3041 while (e<len && brCount!=0)
3042 {
3043 char c=s.at(e);
3044 switch(c)
3045 {
3046 case '<':
3047 if (!insideString && !insideChar)
3048 {
3049 if (e<len-1 && s.at(e+1)=='<')
3050 e++;
3051 else if (roundCount==0)
3052 brCount++;
3053 }
3054 break;
3055 case '>':
3056 if (!insideString && !insideChar)
3057 {
3058 if (e<len-1 && s.at(e+1)=='>')
3059 e++;
3060 else if (roundCount==0)
3061 brCount--;
3062 }
3063 break;
3064 case '(':
3065 if (!insideString && !insideChar)
3066 roundCount++;
3067 break;
3068 case ')':
3069 if (!insideString && !insideChar)
3070 roundCount--;
3071 break;
3072 case '"':
3073 if (!insideChar)
3074 {
3075 if (insideString && pc!='\\')
3076 insideString=FALSE;
3077 else
3078 insideString=TRUE;
3079 }
3080 break;
3081 case '\'':
3082 if (!insideString)
3083 {
3084 if (insideChar && pc!='\\')
3085 insideChar=FALSE;
3086 else
3087 insideChar=TRUE;
3088 }
3089 break;
3090 }
3091 pc = c;
3092 e++;
3093 }
3094 return brCount==0 ? static_cast<int>(e) : -1;
3095}
3096
3097//--------------------------------------------------------------------------------------
3098
3099static void addVariable(const Entry *root,int isFuncPtr=-1)
3100{
3101 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
3102
3103 AUTO_TRACE("VARIABLE_SEC: type='{}' name='{}' args='{}' bodyLine={} endBodyLine={} mGrpId={} relates='{}'",
3104 root->type, root->name, root->args, root->bodyLine, root->endBodyLine, root->mGrpId, root->relates);
3105 //printf("root->parent->name=%s\n",qPrint(root->parent->name));
3106
3107 QCString type = root->type;
3108 QCString name = root->name;
3109 QCString args = root->args;
3110 if (type.isEmpty() && name.find("operator")==-1 &&
3111 (name.find('*')!=-1 || name.find('&')!=-1))
3112 {
3113 // recover from parse error caused by redundant braces
3114 // like in "int *(var[10]);", which is parsed as
3115 // type="" name="int *" args="(var[10])"
3116
3117 type=name;
3118 std::string sargs = args.str();
3119 static const reg::Ex reName(R"(\a\w*)");
3120 reg::Match match;
3121 if (reg::search(sargs,match,reName))
3122 {
3123 name = match.str(); // e.g. 'var' in '(var[10])'
3124 sargs = match.suffix().str(); // e.g. '[10]) in '(var[10])'
3125 size_t j = sargs.find(')');
3126 if (j!=std::string::npos) args=sargs.substr(0,j); // extract, e.g '[10]' from '[10])'
3127 }
3128 }
3129 else
3130 {
3131 int i=isFuncPtr;
3132 if (i==-1 && (root->spec.isAlias())==0) i=findFunctionPtr(type.str(),root->lang); // for typedefs isFuncPtr is not yet set
3133 AUTO_TRACE_ADD("functionPtr={}",i!=-1?"yes":"no");
3134 if (i>=0) // function pointer
3135 {
3136 int ai = type.find('[',i);
3137 if (ai>i) // function pointer array
3138 {
3139 args.prepend(type.right(type.length()-ai));
3140 type=type.left(ai);
3141 }
3142 else if (type.find(')',i)!=-1) // function ptr, not variable like "int (*bla)[10]"
3143 {
3144 type=type.left(type.length()-1);
3145 args.prepend(") ");
3146 }
3147 }
3148 }
3149 AUTO_TRACE_ADD("after correction: type='{}' name='{}' args='{}'",type,name,args);
3150
3151 QCString scope;
3152 name=removeRedundantWhiteSpace(name);
3153
3154 // find the scope of this variable
3155 int index = computeQualifiedIndex(name);
3156 if (index!=-1 && root->parent()->section.isGroupDoc() && root->parent()->tagInfo())
3157 // grouped members are stored with full scope
3158 {
3159 buildScopeFromQualifiedName(name.left(index+2),root->lang,root->tagInfo());
3160 scope=name.left(index);
3161 name=name.mid(index+2);
3162 }
3163 else
3164 {
3165 Entry *p = root->parent();
3166 while (p->section.isScope())
3167 {
3168 QCString scopeName = p->name;
3169 if (!scopeName.isEmpty())
3170 {
3171 scope.prepend(scopeName);
3172 break;
3173 }
3174 p=p->parent();
3175 }
3176 }
3177
3178 type=type.stripWhiteSpace();
3179 ClassDefMutable *cd=nullptr;
3180 bool isRelated=FALSE;
3181 bool isMemberOf=FALSE;
3182
3183 QCString classScope=stripAnonymousNamespaceScope(scope);
3184 if (root->lang==SrcLangExt::CSharp)
3185 {
3186 classScope=mangleCSharpGenericName(classScope);
3187 }
3188 else
3189 {
3190 classScope=stripTemplateSpecifiersFromScope(classScope,FALSE);
3191 }
3192 QCString annScopePrefix=scope.left(scope.length()-classScope.length());
3193
3194
3195 // Look for last :: not part of template specifier
3196 int p=-1;
3197 for (size_t i=0;i<name.length()-1;i++)
3198 {
3199 if (name[i]==':' && name[i+1]==':')
3200 {
3201 p=static_cast<int>(i);
3202 }
3203 else if (name[i]=='<') // skip over template parts,
3204 // i.e. A::B<C::D> => p=1 and
3205 // A<B::C>::D => p=8
3206 {
3207 int e = findEndOfTemplate(name,i+1);
3208 if (e!=-1) i=static_cast<int>(e);
3209 }
3210 }
3211
3212 if (p!=-1) // found it
3213 {
3214 if (type=="friend class" || type=="friend struct" ||
3215 type=="friend union")
3216 {
3217 cd=getClassMutable(scope);
3218 if (cd)
3219 {
3220 addVariableToClass(root, // entry
3221 cd, // class to add member to
3222 MemberType::Friend, // type of member
3223 type, // type value as string
3224 name, // name of the member
3225 args, // arguments as string
3226 FALSE, // from Anonymous scope
3227 nullptr, // anonymous member
3228 Protection::Public, // protection
3229 Relationship::Member // related to a class
3230 );
3231 }
3232 }
3233 if (root->bodyLine!=-1 && root->endBodyLine!=-1) // store the body location for later use
3234 {
3235 Doxygen::staticInitMap.emplace(name.str(),BodyInfo{root->startLine,root->bodyLine,root->endBodyLine});
3236 }
3237
3238
3239 AUTO_TRACE_ADD("static variable {} body=[{}..{}]",name,root->bodyLine,root->endBodyLine);
3240 return; /* skip this member, because it is a
3241 * static variable definition (always?), which will be
3242 * found in a class scope as well, but then we know the
3243 * correct protection level, so only then it will be
3244 * inserted in the correct list!
3245 */
3246 }
3247
3249 if (type=="@")
3251 else if (type.startsWith("typedef "))
3252 mtype=MemberType::Typedef;
3253 else if (type.startsWith("friend "))
3254 mtype=MemberType::Friend;
3255 else if (root->mtype==MethodTypes::Property)
3257 else if (root->mtype==MethodTypes::Event)
3258 mtype=MemberType::Event;
3259 else if (type.find("sequence<") != -1)
3260 mtype=sliceOpt ? MemberType::Sequence : MemberType::Typedef;
3261 else if (type.find("dictionary<") != -1)
3263
3264 if (!root->relates.isEmpty()) // related variable
3265 {
3266 isRelated=TRUE;
3267 isMemberOf=(root->relatesType==RelatesType::MemberOf);
3268 if (getClass(root->relates)==nullptr && !scope.isEmpty())
3269 scope=mergeScopes(scope,root->relates);
3270 else
3271 scope=root->relates;
3272 }
3273
3274 cd=getClassMutable(scope);
3275 if (cd==nullptr && classScope!=scope) cd=getClassMutable(classScope);
3276 if (cd)
3277 {
3278 MemberDef *md=nullptr;
3279
3280 // if cd is an anonymous (=tag less) scope we insert the member
3281 // into a non-anonymous parent scope as well. This is needed to
3282 // be able to refer to it using \var or \fn
3283
3284 //int indentDepth=0;
3285 int si=scope.find('@');
3286 //int anonyScopes = 0;
3287 //bool added=FALSE;
3288
3289 bool inlineSimpleStructs = Config_getBool(INLINE_SIMPLE_STRUCTS);
3290 Relationship relationship = isMemberOf ? Relationship::Foreign :
3291 isRelated ? Relationship::Related :
3292 Relationship::Member ;
3293 if (si!=-1 && !inlineSimpleStructs) // anonymous scope or type
3294 {
3295 QCString pScope;
3296 ClassDefMutable *pcd=nullptr;
3297 pScope = scope.left(std::max(si-2,0)); // scope without tag less parts
3298 if (!pScope.isEmpty())
3299 pScope.prepend(annScopePrefix);
3300 else if (annScopePrefix.length()>2)
3301 pScope=annScopePrefix.left(annScopePrefix.length()-2);
3302 if (name.at(0)!='@')
3303 {
3304 if (!pScope.isEmpty() && (pcd=getClassMutable(pScope)))
3305 {
3306 AUTO_TRACE_ADD("Adding anonymous member to scope '{}'",pScope);
3307 md=addVariableToClass(root, // entry
3308 pcd, // class to add member to
3309 mtype, // member type
3310 type, // type value as string
3311 name, // member name
3312 args, // arguments as string
3313 TRUE, // from anonymous scope
3314 nullptr, // from anonymous member
3315 root->protection,
3316 relationship
3317 );
3318 //added=TRUE;
3319 }
3320 else // anonymous scope inside namespace or file => put variable in the global scope
3321 {
3322 if (mtype==MemberType::Variable)
3323 {
3324 AUTO_TRACE_ADD("Adding anonymous member to global scope '{}'");
3325 md=addVariableToFile(root,mtype,pScope,type,name,args,TRUE,nullptr);
3326 }
3327 //added=TRUE;
3328 }
3329 }
3330 }
3331
3332 addVariableToClass(root, // entry
3333 cd, // class to add member to
3334 mtype, // member type
3335 type, // type value as string
3336 name, // name of the member
3337 args, // arguments as string
3338 FALSE, // from anonymous scope
3339 md, // from anonymous member
3340 root->protection,
3341 relationship
3342 );
3343 }
3344 else if (!name.isEmpty()) // global variable
3345 {
3346 addVariableToFile(root,mtype,scope,type,name,args,FALSE,/*nullptr,*/nullptr);
3347 }
3348
3349}
3350
3351//----------------------------------------------------------------------
3352// Searches the Entry tree for typedef documentation sections.
3353// If found they are stored in their class or in the global list.
3354static void buildTypedefList(const Entry *root)
3355{
3356 //printf("buildVarList(%s)\n",qPrint(rootNav->name()));
3357 if (!root->name.isEmpty() &&
3358 root->section.isVariable() &&
3359 root->type.find("typedef ")!=-1 // its a typedef
3360 )
3361 {
3362 AUTO_TRACE();
3364 QCString scope;
3365 int index = computeQualifiedIndex(rname);
3366 if (index!=-1 && root->parent()->section.isGroupDoc() && root->parent()->tagInfo())
3367 // grouped members are stored with full scope
3368 {
3369 buildScopeFromQualifiedName(rname.left(index+2),root->lang,root->tagInfo());
3370 scope=rname.left(index);
3371 rname=rname.mid(index+2);
3372 }
3373 else
3374 {
3375 scope=root->parent()->name; //stripAnonymousNamespaceScope(root->parent->name);
3376 }
3379 MemberName *mn = Doxygen::functionNameLinkedMap->find(rname);
3380 bool found=false;
3381 if (mn) // symbol with the same name already found
3382 {
3383 for (auto &imd : *mn)
3384 {
3385 if (!imd->isTypedef())
3386 continue;
3387
3388 QCString rtype = root->type;
3389 rtype.stripPrefix("typedef ");
3390
3391 // merge the typedefs only if they're not both grouped, and both are
3392 // either part of the same class, part of the same namespace, or both
3393 // are global (i.e., neither in a class or a namespace)
3394 bool notBothGrouped = root->groups.empty() || imd->getGroupDef()==nullptr; // see example #100
3395 bool bothSameScope = (!cd && !nd) || (cd && imd->getClassDef() == cd) || (nd && imd->getNamespaceDef() == nd);
3396 //printf("imd->isTypedef()=%d imd->typeString()=%s root->type=%s\n",imd->isTypedef(),
3397 // qPrint(imd->typeString()),qPrint(root->type));
3398 if (notBothGrouped && bothSameScope && imd->typeString()==rtype)
3399 {
3400 MemberDefMutable *md = toMemberDefMutable(imd.get());
3401 if (md)
3402 {
3403 md->setDocumentation(root->doc,root->docFile,root->docLine);
3405 md->setDocsForDefinition(!root->proto);
3406 md->setBriefDescription(root->brief,root->briefFile,root->briefLine);
3408 md->setRefItems(root->sli);
3409 md->addQualifiers(root->qualifiers);
3410
3411 // merge ingroup specifiers
3412 if (md->getGroupDef()==nullptr && !root->groups.empty())
3413 {
3414 addMemberToGroups(root,md);
3415 }
3416 else if (md->getGroupDef()!=nullptr && root->groups.empty())
3417 {
3418 //printf("existing member is grouped, new member not\n");
3419 }
3420 else if (md->getGroupDef()!=nullptr && !root->groups.empty())
3421 {
3422 //printf("both members are grouped\n");
3423 }
3424 found=true;
3425 break;
3426 }
3427 }
3428 }
3429 }
3430 if (found)
3431 {
3432 AUTO_TRACE_ADD("typedef '{}' already found",rname);
3433 // mark the entry as processed, as we copied everything from it elsewhere
3434 // also, otherwise, due to containing `typedef` it may later get treated
3435 // as a function typedef in filterMemberDocumentation, which is incorrect
3436 root->markAsProcessed();
3437 }
3438 else
3439 {
3440 AUTO_TRACE_ADD("new typedef '{}'",rname);
3441 addVariable(root);
3442 }
3443
3444 }
3445 for (const auto &e : root->children())
3446 if (!e->section.isEnum())
3447 buildTypedefList(e.get());
3448}
3449
3450//----------------------------------------------------------------------
3451// Searches the Entry tree for sequence documentation sections.
3452// If found they are stored in the global list.
3453static void buildSequenceList(const Entry *root)
3454{
3455 if (!root->name.isEmpty() &&
3456 root->section.isVariable() &&
3457 root->type.find("sequence<")!=-1 // it's a sequence
3458 )
3459 {
3460 AUTO_TRACE();
3461 addVariable(root);
3462 }
3463 for (const auto &e : root->children())
3464 if (!e->section.isEnum())
3465 buildSequenceList(e.get());
3466}
3467
3468//----------------------------------------------------------------------
3469// Searches the Entry tree for dictionary documentation sections.
3470// If found they are stored in the global list.
3471static void buildDictionaryList(const Entry *root)
3472{
3473 if (!root->name.isEmpty() &&
3474 root->section.isVariable() &&
3475 root->type.find("dictionary<")!=-1 // it's a dictionary
3476 )
3477 {
3478 AUTO_TRACE();
3479 addVariable(root);
3480 }
3481 for (const auto &e : root->children())
3482 if (!e->section.isEnum())
3483 buildDictionaryList(e.get());
3484}
3485
3486//----------------------------------------------------------------------
3487// Searches the Entry tree for Variable documentation sections.
3488// If found they are stored in their class or in the global list.
3489
3490static void buildVarList(const Entry *root)
3491{
3492 //printf("buildVarList(%s) section=%08x\n",qPrint(rootNav->name()),rootNav->section());
3493 int isFuncPtr=-1;
3494 if (!root->name.isEmpty() &&
3495 (root->type.isEmpty() || g_compoundKeywords.find(root->type.str())==g_compoundKeywords.end()) &&
3496 (
3497 (root->section.isVariable() && // it's a variable
3498 root->type.find("typedef ")==-1 // and not a typedef
3499 ) ||
3500 (root->section.isFunction() && // or maybe a function pointer variable
3501 (isFuncPtr=findFunctionPtr(root->type.str(),root->lang))!=-1
3502 ) ||
3503 (root->section.isFunction() && // class variable initialized by constructor
3505 )
3506 )
3507 ) // documented variable
3508 {
3509 AUTO_TRACE();
3510 addVariable(root,isFuncPtr);
3511 }
3512 for (const auto &e : root->children())
3513 if (!e->section.isEnum())
3514 buildVarList(e.get());
3515}
3516
3517//----------------------------------------------------------------------
3518// Searches the Entry tree for Interface sections (UNO IDL only).
3519// If found they are stored in their service or in the global list.
3520//
3521
3523 const Entry *root,
3524 ClassDefMutable *cd,
3525 QCString const& rname)
3526{
3527 FileDef *fd = root->fileDef();
3528 enum MemberType type = root->section.isExportedInterface() ? MemberType::Interface : MemberType::Service;
3529 QCString fileName = root->fileName;
3530 if (fileName.isEmpty() && root->tagInfo())
3531 {
3532 fileName = root->tagInfo()->tagName;
3533 }
3534 auto md = createMemberDef(
3535 fileName, root->startLine, root->startColumn, root->type, rname,
3536 "", "", root->protection, root->virt, root->isStatic, Relationship::Member,
3537 type, ArgumentList(), root->argList, root->metaData);
3538 auto mmd = toMemberDefMutable(md.get());
3539 mmd->setTagInfo(root->tagInfo());
3540 mmd->setMemberClass(cd);
3541 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
3542 mmd->setDocsForDefinition(false);
3543 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
3544 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
3545 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
3546 mmd->setMemberSpecifiers(root->spec);
3547 mmd->setVhdlSpecifiers(root->vhdlSpec);
3548 mmd->setMemberGroupId(root->mGrpId);
3549 mmd->setTypeConstraints(root->typeConstr);
3550 mmd->setLanguage(root->lang);
3551 mmd->setBodyDef(fd);
3552 mmd->setFileDef(fd);
3553 mmd->addSectionsToDefinition(root->anchors);
3554 QCString const def = root->type + " " + rname;
3555 mmd->setDefinition(def);
3557 mmd->addQualifiers(root->qualifiers);
3558
3559 AUTO_TRACE("Interface member: fileName='{}' type='{}' name='{}' mtype='{}' prot={} virt={} state={} proto={} def='{}'",
3560 fileName,root->type,rname,type,root->protection,root->virt,root->isStatic,root->proto,def);
3561
3562 // add member to the class cd
3563 cd->insertMember(md.get());
3564 // also add the member as a "base" (to get nicer diagrams)
3565 // "optional" interface/service get Protected which turns into dashed line
3566 BaseInfo base(rname,
3567 root->spec.isOptional() ? Protection::Protected : Protection::Public, Specifier::Normal);
3568 TemplateNameMap templateNames;
3569 findClassRelation(root,cd,cd,&base,templateNames,DocumentedOnly,true) ||
3570 findClassRelation(root,cd,cd,&base,templateNames,Undocumented,true);
3571 // add file to list of used files
3572 cd->insertUsedFile(fd);
3573
3574 addMemberToGroups(root,md.get());
3576 root->markAsProcessed();
3577 mmd->setRefItems(root->sli);
3578
3579 // add member to the global list of all members
3580 MemberName *mn = Doxygen::memberNameLinkedMap->add(rname);
3581 mn->push_back(std::move(md));
3582}
3583
3584static void buildInterfaceAndServiceList(const Entry *root)
3585{
3586 if (root->section.isExportedInterface() || root->section.isIncludedService())
3587 {
3588 AUTO_TRACE("Exported interface/included service: type='{}' scope='{}' name='{}' args='{}'"
3589 " relates='{}' relatesType='{}' file='{}' line={} bodyLine={} #tArgLists={}"
3590 " mGrpId={} spec={} proto={} docFile='{}'",
3591 root->type, root->parent()->name, root->name, root->args,
3592 root->relates, root->relatesType, root->fileName, root->startLine, root->bodyLine, root->tArgLists.size(),
3593 root->mGrpId, root->spec, root->proto, root->docFile);
3594
3596
3597 if (!rname.isEmpty())
3598 {
3599 QCString scope = root->parent()->name;
3600 ClassDefMutable *cd = getClassMutable(scope);
3601 assert(cd);
3602 if (cd && ((ClassDef::Interface == cd->compoundType()) ||
3603 (ClassDef::Service == cd->compoundType()) ||
3605 {
3607 }
3608 else
3609 {
3610 assert(false); // was checked by scanner.l
3611 }
3612 }
3613 else if (rname.isEmpty())
3614 {
3615 warn(root->fileName,root->startLine,
3616 "Illegal member name found.");
3617 }
3618 }
3619 // can only have these in IDL anyway
3620 switch (root->lang)
3621 {
3622 case SrcLangExt::Unknown: // fall through (root node always is Unknown)
3623 case SrcLangExt::IDL:
3624 for (const auto &e : root->children()) buildInterfaceAndServiceList(e.get());
3625 break;
3626 default:
3627 return; // nothing to do here
3628 }
3629}
3630
3631
3632//----------------------------------------------------------------------
3633// Searches the Entry tree for Function sections.
3634// If found they are stored in their class or in the global list.
3635
3636static void addMethodToClass(const Entry *root,ClassDefMutable *cd,
3637 const QCString &rtype,const QCString &rname,const QCString &rargs,
3638 bool isFriend,
3639 Protection protection,bool stat,Specifier virt,TypeSpecifier spec,
3640 const QCString &relates
3641 )
3642{
3643 FileDef *fd=root->fileDef();
3644
3645 QCString type = rtype;
3646 QCString args = rargs;
3647
3649 name.stripPrefix("::");
3650
3652 if (isFriend) mtype=MemberType::Friend;
3653 else if (root->mtype==MethodTypes::Signal) mtype=MemberType::Signal;
3654 else if (root->mtype==MethodTypes::Slot) mtype=MemberType::Slot;
3655 else if (root->mtype==MethodTypes::DCOP) mtype=MemberType::DCOP;
3656
3657 // strip redundant template specifier for constructors
3658 int i = -1;
3659 int j = -1;
3660 if ((fd==nullptr || fd->getLanguage()==SrcLangExt::Cpp) &&
3661 !name.startsWith("operator ") && // not operator
3662 (i=name.find('<'))!=-1 && // containing <
3663 (j=name.find('>'))!=-1 && // or >
3664 (j!=i+2 || name.at(i+1)!='=') // but not the C++20 spaceship operator <=>
3665 )
3666 {
3667 name=name.left(i);
3668 }
3669
3670 QCString fileName = root->fileName;
3671 if (fileName.isEmpty() && root->tagInfo())
3672 {
3673 fileName = root->tagInfo()->tagName;
3674 }
3675
3676 //printf("root->name='%s; args='%s' root->argList='%s'\n",
3677 // qPrint(root->name),qPrint(args),qPrint(argListToString(root->argList))
3678 // );
3679
3680 // adding class member
3681 Relationship relationship = relates.isEmpty() ? Relationship::Member :
3682 root->relatesType==RelatesType::MemberOf ? Relationship::Foreign :
3683 Relationship::Related ;
3684 auto md = createMemberDef(
3685 fileName,root->startLine,root->startColumn,
3686 type,name,args,root->exception,
3687 protection,virt,
3688 stat && root->relatesType!=RelatesType::MemberOf,
3689 relationship,
3690 mtype,!root->tArgLists.empty() ? root->tArgLists.back() : ArgumentList(),
3691 root->argList, root->metaData);
3692 auto mmd = toMemberDefMutable(md.get());
3693 mmd->setTagInfo(root->tagInfo());
3694 mmd->setMemberClass(cd);
3695 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
3696 mmd->setDocsForDefinition(!root->proto);
3697 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
3698 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
3699 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
3700 mmd->setMemberSpecifiers(spec);
3701 mmd->setVhdlSpecifiers(root->vhdlSpec);
3702 mmd->setMemberGroupId(root->mGrpId);
3703 mmd->setTypeConstraints(root->typeConstr);
3704 mmd->setLanguage(root->lang);
3705 mmd->setRequiresClause(root->req);
3706 mmd->setId(root->id);
3707 mmd->setBodyDef(fd);
3708 mmd->setFileDef(fd);
3709 mmd->addSectionsToDefinition(root->anchors);
3710 QCString def;
3712 SrcLangExt lang = cd->getLanguage();
3713 QCString scopeSeparator=getLanguageSpecificSeparator(lang);
3714 if (scopeSeparator!="::")
3715 {
3716 qualScope = substitute(qualScope,"::",scopeSeparator);
3717 }
3718 if (lang==SrcLangExt::PHP)
3719 {
3720 // for PHP we use Class::method and Namespace\method
3721 scopeSeparator="::";
3722 }
3723// QCString optArgs = root->argList.empty() ? args : QCString();
3724 if (!relates.isEmpty() || isFriend || Config_getBool(HIDE_SCOPE_NAMES))
3725 {
3726 if (!type.isEmpty())
3727 {
3728 def=type+" "+name; //+optArgs;
3729 }
3730 else
3731 {
3732 def=name; //+optArgs;
3733 }
3734 }
3735 else
3736 {
3737 if (!type.isEmpty())
3738 {
3739 def=type+" "+qualScope+scopeSeparator+name; //+optArgs;
3740 }
3741 else
3742 {
3743 def=qualScope+scopeSeparator+name; //+optArgs;
3744 }
3745 }
3746 def.stripPrefix("friend ");
3747 mmd->setDefinition(def);
3749 mmd->addQualifiers(root->qualifiers);
3750
3751 AUTO_TRACE("function member: type='{}' scope='{}' name='{}' args='{}' proto={} def='{}'",
3752 type, qualScope, rname, args, root->proto, def);
3753
3754 // add member to the class cd
3755 cd->insertMember(md.get());
3756 // add file to list of used files
3757 cd->insertUsedFile(fd);
3758
3759 addMemberToGroups(root,md.get());
3761 root->markAsProcessed();
3762 mmd->setRefItems(root->sli);
3763
3764 // add member to the global list of all members
3765 //printf("Adding member=%s class=%s\n",qPrint(md->name()),qPrint(cd->name()));
3767 mn->push_back(std::move(md));
3768}
3769
3770//------------------------------------------------------------------------------------------
3771
3772static void addGlobalFunction(const Entry *root,const QCString &rname,const QCString &sc)
3773{
3774 QCString scope = sc;
3775
3776 // new global function
3778 auto md = createMemberDef(
3779 root->fileName,root->startLine,root->startColumn,
3780 root->type,name,root->args,root->exception,
3781 root->protection,root->virt,root->isStatic,Relationship::Member,
3783 !root->tArgLists.empty() ? root->tArgLists.back() : ArgumentList(),
3784 root->argList,root->metaData);
3785 auto mmd = toMemberDefMutable(md.get());
3786 mmd->setTagInfo(root->tagInfo());
3787 mmd->setLanguage(root->lang);
3788 mmd->setId(root->id);
3789 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
3790 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
3791 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
3792 mmd->setPrototype(root->proto,root->fileName,root->startLine,root->startColumn);
3793 mmd->setDocsForDefinition(!root->proto);
3794 mmd->setTypeConstraints(root->typeConstr);
3795 //md->setBody(root->body);
3796 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
3797 FileDef *fd=root->fileDef();
3798 mmd->setBodyDef(fd);
3799 mmd->addSectionsToDefinition(root->anchors);
3800 mmd->setMemberSpecifiers(root->spec);
3801 mmd->setVhdlSpecifiers(root->vhdlSpec);
3802 mmd->setMemberGroupId(root->mGrpId);
3803 mmd->setRequiresClause(root->req);
3804 mmd->setExplicitExternal(root->explicitExternal,root->fileName,root->startLine,root->startColumn);
3805
3806 NamespaceDefMutable *nd = nullptr;
3807 // see if the function is inside a namespace that was not part of
3808 // the name already (in that case nd should be non-zero already)
3809 if (root->parent()->section.isNamespace())
3810 {
3811 //QCString nscope=removeAnonymousScopes(root->parent()->name);
3812 QCString nscope=root->parent()->name;
3813 if (!nscope.isEmpty())
3814 {
3815 nd = getResolvedNamespaceMutable(nscope);
3816 }
3817 }
3818 else if (root->parent()->section.isGroupDoc() && !scope.isEmpty())
3819 {
3821 }
3822
3823 if (!scope.isEmpty())
3824 {
3826 if (sep!="::")
3827 {
3828 scope = substitute(scope,"::",sep);
3829 }
3830 scope+=sep;
3831 }
3832
3833 if (Config_getBool(HIDE_SCOPE_NAMES)) scope = "";
3834 QCString def;
3835 //QCString optArgs = root->argList.empty() ? QCString() : root->args;
3836 if (!root->type.isEmpty())
3837 {
3838 def=root->type+" "+scope+name; //+optArgs;
3839 }
3840 else
3841 {
3842 def=scope+name; //+optArgs;
3843 }
3844 AUTO_TRACE("new non-member function type='{}' scope='{}' name='{}' args='{}' proto={} def='{}'",
3845 root->type,scope,rname,root->args,root->proto,def);
3846 mmd->setDefinition(def);
3848 mmd->addQualifiers(root->qualifiers);
3849
3850 mmd->setRefItems(root->sli);
3851 if (nd && !nd->name().isEmpty() && nd->name().at(0)!='@')
3852 {
3853 // add member to namespace
3854 mmd->setNamespace(nd);
3855 nd->insertMember(md.get());
3856 }
3857 if (fd)
3858 {
3859 // add member to the file (we do this even if we have already
3860 // inserted it into the namespace)
3861 mmd->setFileDef(fd);
3862 fd->insertMember(md.get());
3863 }
3864
3865 addMemberToGroups(root,md.get());
3867 if (root->relatesType == RelatesType::Simple) // if this is a relatesalso command,
3868 // allow find Member to pick it up
3869 {
3870 root->markAsProcessed(); // Otherwise we have finished with this entry.
3871 }
3872
3873 // add member to the list of file members
3875 mn->push_back(std::move(md));
3876}
3877
3878//------------------------------------------------------------------------------------------
3879
3880static void buildFunctionList(const Entry *root)
3881{
3882 if (root->section.isFunction())
3883 {
3884 AUTO_TRACE("member function: type='{}' scope='{}' name='{}' args='{}' relates='{}' relatesType='{}'"
3885 " file='{}' line={} bodyLine={} #tArgLists={} mGrpId={}"
3886 " spec={} proto={} docFile='{}'",
3887 root->type, root->parent()->name, root->name, root->args, root->relates, root->relatesType,
3888 root->fileName, root->startLine, root->bodyLine, root->tArgLists.size(), root->mGrpId,
3889 root->spec, root->proto, root->docFile);
3890
3891 bool isFriend=root->type.find("friend ")!=-1;
3893 //printf("rname=%s\n",qPrint(rname));
3894
3895 QCString scope;
3896 int index = computeQualifiedIndex(rname);
3897 if (index!=-1 && root->parent()->section.isGroupDoc() && root->parent()->tagInfo())
3898 // grouped members are stored with full scope
3899 {
3900 buildScopeFromQualifiedName(rname.left(index+2),root->lang,root->tagInfo());
3901 scope=rname.left(index);
3902 rname=rname.mid(index+2);
3903 }
3904 else
3905 {
3906 scope=root->parent()->name; //stripAnonymousNamespaceScope(root->parent->name);
3907 }
3908 if (!rname.isEmpty() && scope.find('@')==-1)
3909 {
3910 // check if this function's parent is a class
3911 if (root->lang==SrcLangExt::CSharp)
3912 {
3913 scope=mangleCSharpGenericName(scope);
3914 }
3915 else
3916 {
3918 }
3919
3920 FileDef *rfd=root->fileDef();
3921
3922 int memIndex=rname.findRev("::");
3923
3925 if (cd && scope+"::"==rname.left(scope.length()+2)) // found A::f inside A
3926 {
3927 // strip scope from name
3928 rname=rname.right(rname.length()-root->parent()->name.length()-2);
3929 }
3930
3931 bool isMember=FALSE;
3932 if (memIndex!=-1)
3933 {
3934 int ts=rname.find('<');
3935 int te=rname.find('>');
3936 if (memIndex>0 && (ts==-1 || te==-1))
3937 {
3938 // note: the following code was replaced by inMember=TRUE to deal with a
3939 // function rname='X::foo' of class X inside a namespace also called X...
3940 // bug id 548175
3941 //nd = Doxygen::namespaceLinkedMap->find(rname.left(memIndex));
3942 //isMember = nd==nullptr;
3943 //if (nd)
3944 //{
3945 // // strip namespace scope from name
3946 // scope=rname.left(memIndex);
3947 // rname=rname.right(rname.length()-memIndex-2);
3948 //}
3949 isMember = TRUE;
3950 }
3951 else
3952 {
3953 isMember=memIndex<ts || memIndex>te;
3954 }
3955 }
3956
3957 if (!root->parent()->name.isEmpty() && root->parent()->section.isCompound() && cd)
3958 {
3959 AUTO_TRACE_ADD("member '{}' of class '{}'", rname,cd->name());
3960 addMethodToClass(root,cd,root->type,rname,root->args,isFriend,
3961 root->protection,root->isStatic,root->virt,root->spec,root->relates);
3962 }
3963 else if (root->parent()->section.isObjcImpl() && cd)
3964 {
3965 const MemberDef *md = cd->getMemberByName(rname);
3966 if (md)
3967 {
3968 MemberDefMutable *mdm = toMemberDefMutable(const_cast<MemberDef*>(md));
3969 if (mdm)
3970 {
3971 mdm->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
3972 mdm->setBodyDef(root->fileDef());
3973 }
3974 }
3975 }
3976 else if (!root->parent()->section.isCompound() && !root->parent()->section.isObjcImpl() &&
3977 !isMember &&
3978 (root->relates.isEmpty() || root->relatesType==RelatesType::Duplicate) &&
3979 !root->type.startsWith("extern ") && !root->type.startsWith("typedef ")
3980 )
3981 // no member => unrelated function
3982 {
3983 /* check the uniqueness of the function name in the file.
3984 * A file could contain a function prototype and a function definition
3985 * or even multiple function prototypes.
3986 */
3987 bool found=FALSE;
3988 MemberDef *md_found=nullptr;
3989 MemberName *mn = Doxygen::functionNameLinkedMap->find(rname);
3990 if (mn)
3991 {
3992 AUTO_TRACE_ADD("function '{}' already found",rname);
3993 for (const auto &imd : *mn)
3994 {
3995 MemberDefMutable *md = toMemberDefMutable(imd.get());
3996 if (md)
3997 {
3998 const NamespaceDef *mnd = md->getNamespaceDef();
3999 NamespaceDef *rnd = nullptr;
4000 //printf("root namespace=%s\n",qPrint(rootNav->parent()->name()));
4001 QCString fullScope = scope;
4002 QCString parentScope = root->parent()->name;
4003 if (!parentScope.isEmpty() && !leftScopeMatch(parentScope,scope))
4004 {
4005 if (!scope.isEmpty()) fullScope.prepend("::");
4006 fullScope.prepend(parentScope);
4007 }
4008 //printf("fullScope=%s\n",qPrint(fullScope));
4009 rnd = getResolvedNamespace(fullScope);
4010 const FileDef *mfd = md->getFileDef();
4011 QCString nsName,rnsName;
4012 if (mnd) nsName = mnd->name();
4013 if (rnd) rnsName = rnd->name();
4014 //printf("matching arguments for %s%s %s%s\n",
4015 // qPrint(md->name()),md->argsString(),qPrint(rname),qPrint(argListToString(root->argList)));
4016 const ArgumentList &mdAl = md->argumentList();
4017 const ArgumentList &mdTempl = md->templateArguments();
4018
4019 // in case of template functions, we need to check if the
4020 // functions have the same number of template parameters
4021 bool sameTemplateArgs = TRUE;
4022 bool matchingReturnTypes = TRUE;
4023 bool sameRequiresClause = TRUE;
4024 if (!mdTempl.empty() && !root->tArgLists.empty())
4025 {
4026 sameTemplateArgs = matchTemplateArguments(mdTempl,root->tArgLists.back());
4027 if (md->typeString()!=removeRedundantWhiteSpace(root->type))
4028 {
4029 matchingReturnTypes = FALSE;
4030 }
4031 if (md->requiresClause()!=root->req)
4032 {
4033 sameRequiresClause = FALSE;
4034 }
4035 }
4036 else if (!mdTempl.empty() || !root->tArgLists.empty())
4037 { // if one has template parameters and the other doesn't then that also counts as a
4038 // difference
4039 sameTemplateArgs = FALSE;
4040 }
4041
4042 bool staticsInDifferentFiles =
4043 root->isStatic && md->isStatic() && root->fileName!=md->getDefFileName();
4044
4045 if (
4046 matchArguments2(md->getOuterScope(),mfd,&mdAl,
4047 rnd ? rnd : Doxygen::globalScope,rfd,&root->argList,
4048 FALSE,root->lang) &&
4049 sameTemplateArgs &&
4050 matchingReturnTypes &&
4051 sameRequiresClause &&
4052 !staticsInDifferentFiles
4053 )
4054 {
4055 GroupDef *gd=nullptr;
4056 if (!root->groups.empty() && !root->groups.front().groupname.isEmpty())
4057 {
4058 gd = Doxygen::groupLinkedMap->find(root->groups.front().groupname);
4059 }
4060 //printf("match!\n");
4061 //printf("mnd=%p rnd=%p nsName=%s rnsName=%s\n",mnd,rnd,qPrint(nsName),qPrint(rnsName));
4062 // see if we need to create a new member
4063 found=(mnd && rnd && nsName==rnsName) || // members are in the same namespace
4064 ((mnd==nullptr && rnd==nullptr && mfd!=nullptr && // no external reference and
4065 mfd->absFilePath()==root->fileName // prototype in the same file
4066 )
4067 );
4068 // otherwise, allow a duplicate global member with the same argument list
4069 if (!found && gd && gd==md->getGroupDef() && nsName==rnsName)
4070 {
4071 // member is already in the group, so we don't want to add it again.
4072 found=TRUE;
4073 }
4074
4075 AUTO_TRACE_ADD("combining function with prototype found={} in namespace '{}'",found,nsName);
4076
4077 if (found)
4078 {
4079 // merge argument lists
4080 ArgumentList mergedArgList = root->argList;
4081 mergeArguments(const_cast<ArgumentList&>(mdAl),mergedArgList,!root->doc.isEmpty());
4082 // merge documentation
4083 if (md->documentation().isEmpty() && !root->doc.isEmpty())
4084 {
4085 if (root->proto)
4086 {
4088 }
4089 else
4090 {
4092 }
4093 }
4094
4095 md->setDocumentation(root->doc,root->docFile,root->docLine);
4097 md->setDocsForDefinition(!root->proto);
4098 if (md->getStartBodyLine()==-1 && root->bodyLine!=-1)
4099 {
4100 md->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
4101 md->setBodyDef(rfd);
4102 }
4103
4104 if (md->briefDescription().isEmpty() && !root->brief.isEmpty())
4105 {
4106 md->setArgsString(root->args);
4107 }
4108 md->setBriefDescription(root->brief,root->briefFile,root->briefLine);
4109
4111
4113 md->addQualifiers(root->qualifiers);
4114
4115 // merge ingroup specifiers
4116 if (md->getGroupDef()==nullptr && !root->groups.empty())
4117 {
4118 addMemberToGroups(root,md);
4119 }
4120 else if (md->getGroupDef()!=nullptr && root->groups.empty())
4121 {
4122 //printf("existing member is grouped, new member not\n");
4123 }
4124 else if (md->getGroupDef()!=nullptr && !root->groups.empty())
4125 {
4126 //printf("both members are grouped\n");
4127 }
4129
4130 // if md is a declaration and root is the corresponding
4131 // definition, then turn md into a definition.
4132 if (md->isPrototype() && !root->proto)
4133 {
4134 md->setDeclFile(md->getDefFileName(),md->getDefLine(),md->getDefColumn());
4135 md->setPrototype(FALSE,root->fileName,root->startLine,root->startColumn);
4136 }
4137 // if md is already the definition, then add the declaration info
4138 else if (!md->isPrototype() && root->proto)
4139 {
4140 md->setDeclFile(root->fileName,root->startLine,root->startColumn);
4141 }
4142 }
4143 }
4144 }
4145 if (found)
4146 {
4147 md_found = md;
4148 break;
4149 }
4150 }
4151 }
4152 if (!found) /* global function is unique with respect to the file */
4153 {
4154 addGlobalFunction(root,rname,scope);
4155 }
4156 else
4157 {
4158 FileDef *fd=root->fileDef();
4159 if (fd)
4160 {
4161 // add member to the file (we do this even if we have already
4162 // inserted it into the namespace)
4163 fd->insertMember(md_found);
4164 }
4165 }
4166
4167 AUTO_TRACE_ADD("unrelated function type='{}' name='{}' args='{}'",root->type,rname,root->args);
4168 }
4169 else
4170 {
4171 AUTO_TRACE_ADD("function '{}' is not processed",rname);
4172 }
4173 }
4174 else if (rname.isEmpty())
4175 {
4176 warn(root->fileName,root->startLine,
4177 "Illegal member name found."
4178 );
4179 }
4180 }
4181 for (const auto &e : root->children()) buildFunctionList(e.get());
4182}
4183
4184//----------------------------------------------------------------------
4185
4186static void findFriends()
4187{
4188 AUTO_TRACE();
4189 for (const auto &fn : *Doxygen::functionNameLinkedMap) // for each global function name
4190 {
4191 MemberName *mn = Doxygen::memberNameLinkedMap->find(fn->memberName());
4192 if (mn)
4193 { // there are members with the same name
4194 // for each function with that name
4195 for (const auto &ifmd : *fn)
4196 {
4197 MemberDefMutable *fmd = toMemberDefMutable(ifmd.get());
4198 // for each member with that name
4199 for (const auto &immd : *mn)
4200 {
4201 MemberDefMutable *mmd = toMemberDefMutable(immd.get());
4202 //printf("Checking for matching arguments
4203 // mmd->isRelated()=%d mmd->isFriend()=%d mmd->isFunction()=%d\n",
4204 // mmd->isRelated(),mmd->isFriend(),mmd->isFunction());
4205 if (fmd && mmd &&
4206 (mmd->isFriend() || (mmd->isRelated() && mmd->isFunction())) &&
4207 matchArguments2(mmd->getOuterScope(), mmd->getFileDef(), &mmd->argumentList(),
4208 fmd->getOuterScope(), fmd->getFileDef(), &fmd->argumentList(),
4209 TRUE,mmd->getLanguage()
4210 )
4211
4212 ) // if the member is related and the arguments match then the
4213 // function is actually a friend.
4214 {
4215 AUTO_TRACE_ADD("Merging related global and member '{}' isFriend={} isRelated={} isFunction={}",
4216 mmd->name(),mmd->isFriend(),mmd->isRelated(),mmd->isFunction());
4217 const ArgumentList &mmdAl = mmd->argumentList();
4218 const ArgumentList &fmdAl = fmd->argumentList();
4219 mergeArguments(const_cast<ArgumentList&>(fmdAl),const_cast<ArgumentList&>(mmdAl));
4220
4221 // reset argument lists to add missing default parameters
4222 QCString mmdAlStr = argListToString(mmdAl);
4223 QCString fmdAlStr = argListToString(fmdAl);
4224 mmd->setArgsString(mmdAlStr);
4225 fmd->setArgsString(fmdAlStr);
4226 mmd->moveDeclArgumentList(std::make_unique<ArgumentList>(mmdAl));
4227 fmd->moveDeclArgumentList(std::make_unique<ArgumentList>(fmdAl));
4228 AUTO_TRACE_ADD("friend args='{}' member args='{}'",argListToString(fmd->argumentList()),argListToString(mmd->argumentList()));
4229
4230 if (!fmd->documentation().isEmpty())
4231 {
4232 mmd->setDocumentation(fmd->documentation(),fmd->docFile(),fmd->docLine());
4233 }
4234 else if (!mmd->documentation().isEmpty())
4235 {
4236 fmd->setDocumentation(mmd->documentation(),mmd->docFile(),mmd->docLine());
4237 }
4238 if (mmd->briefDescription().isEmpty() && !fmd->briefDescription().isEmpty())
4239 {
4240 mmd->setBriefDescription(fmd->briefDescription(),fmd->briefFile(),fmd->briefLine());
4241 }
4242 else if (!mmd->briefDescription().isEmpty() && !fmd->briefDescription().isEmpty())
4243 {
4244 fmd->setBriefDescription(mmd->briefDescription(),mmd->briefFile(),mmd->briefLine());
4245 }
4246 if (!fmd->inbodyDocumentation().isEmpty())
4247 {
4249 }
4250 else if (!mmd->inbodyDocumentation().isEmpty())
4251 {
4253 }
4254 //printf("body mmd %d fmd %d\n",mmd->getStartBodyLine(),fmd->getStartBodyLine());
4255 if (mmd->getStartBodyLine()==-1 && fmd->getStartBodyLine()!=-1)
4256 {
4257 mmd->setBodySegment(fmd->getDefLine(),fmd->getStartBodyLine(),fmd->getEndBodyLine());
4258 mmd->setBodyDef(fmd->getBodyDef());
4259 //mmd->setBodyMember(fmd);
4260 }
4261 else if (mmd->getStartBodyLine()!=-1 && fmd->getStartBodyLine()==-1)
4262 {
4263 fmd->setBodySegment(mmd->getDefLine(),mmd->getStartBodyLine(),mmd->getEndBodyLine());
4264 fmd->setBodyDef(mmd->getBodyDef());
4265 //fmd->setBodyMember(mmd);
4266 }
4268
4270
4271 mmd->addQualifiers(fmd->getQualifiers());
4272 fmd->addQualifiers(mmd->getQualifiers());
4273
4274 }
4275 }
4276 }
4277 }
4278 }
4279}
4280
4281//----------------------------------------------------------------------
4282
4284{
4285 AUTO_TRACE();
4286
4287 // find matching function declaration and definitions.
4288 for (const auto &mn : *Doxygen::functionNameLinkedMap)
4289 {
4290 //printf("memberName=%s count=%zu\n",qPrint(mn->memberName()),mn->size());
4291 /* find a matching function declaration and definition for this function */
4292 for (const auto &imdec : *mn)
4293 {
4294 MemberDefMutable *mdec = toMemberDefMutable(imdec.get());
4295 if (mdec &&
4296 (mdec->isPrototype() ||
4297 (mdec->isVariable() && mdec->isExternal())
4298 ))
4299 {
4300 for (const auto &imdef : *mn)
4301 {
4302 MemberDefMutable *mdef = toMemberDefMutable(imdef.get());
4303 if (mdef && mdec!=mdef &&
4304 mdec->getNamespaceDef()==mdef->getNamespaceDef())
4305 {
4307 }
4308 }
4309 }
4310 }
4311 }
4312}
4313
4314//----------------------------------------------------------------------
4315
4317{
4318 AUTO_TRACE();
4319 for (const auto &mn : *Doxygen::functionNameLinkedMap)
4320 {
4321 MemberDefMutable *mdef=nullptr,*mdec=nullptr;
4322 /* find a matching function declaration and definition for this function */
4323 for (const auto &imd : *mn)
4324 {
4325 MemberDefMutable *md = toMemberDefMutable(imd.get());
4326 if (md)
4327 {
4328 if (md->isPrototype())
4329 mdec=md;
4330 else if (md->isVariable() && md->isExternal())
4331 mdec=md;
4332
4333 if (md->isFunction() && !md->isStatic() && !md->isPrototype())
4334 mdef=md;
4335 else if (md->isVariable() && !md->isExternal() && !md->isStatic())
4336 mdef=md;
4337 }
4338
4339 if (mdef && mdec) break;
4340 }
4341 if (mdef && mdec)
4342 {
4343 const ArgumentList &mdefAl = mdef->argumentList();
4344 const ArgumentList &mdecAl = mdec->argumentList();
4345 if (
4346 matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),const_cast<ArgumentList*>(&mdefAl),
4347 mdec->getOuterScope(),mdec->getFileDef(),const_cast<ArgumentList*>(&mdecAl),
4348 TRUE,mdef->getLanguage()
4349 )
4350 ) /* match found */
4351 {
4352 AUTO_TRACE_ADD("merging references for mdec={} mdef={}",mdec->name(),mdef->name());
4353 mdef->mergeReferences(mdec);
4354 mdec->mergeReferences(mdef);
4355 mdef->mergeReferencedBy(mdec);
4356 mdec->mergeReferencedBy(mdef);
4357 }
4358 }
4359 }
4360}
4361
4362//----------------------------------------------------------------------
4363
4365{
4366 AUTO_TRACE();
4367 // find match between function declaration and definition for
4368 // related functions
4369 for (const auto &mn : *Doxygen::functionNameLinkedMap)
4370 {
4371 /* find a matching function declaration and definition for this function */
4372 // for each global function
4373 for (const auto &imd : *mn)
4374 {
4375 MemberDefMutable *md = toMemberDefMutable(imd.get());
4376 if (md)
4377 {
4378 //printf(" Function '%s'\n",qPrint(md->name()));
4379 MemberName *rmn = Doxygen::memberNameLinkedMap->find(md->name());
4380 if (rmn) // check if there is a member with the same name
4381 {
4382 //printf(" Member name found\n");
4383 // for each member with the same name
4384 for (const auto &irmd : *rmn)
4385 {
4386 MemberDefMutable *rmd = toMemberDefMutable(irmd.get());
4387 //printf(" Member found: related='%d'\n",rmd->isRelated());
4388 if (rmd &&
4389 (rmd->isRelated() || rmd->isForeign()) && // related function
4391 rmd->getOuterScope(),rmd->getFileDef(),&rmd->argumentList(),
4392 TRUE,md->getLanguage()
4393 )
4394 )
4395 {
4396 AUTO_TRACE_ADD("Found related member '{}'",md->name());
4397 if (rmd->relatedAlso())
4398 md->setRelatedAlso(rmd->relatedAlso());
4399 else if (rmd->isForeign())
4400 md->makeForeign();
4401 else
4402 md->makeRelated();
4403 }
4404 }
4405 }
4406 }
4407 }
4408 }
4409}
4410
4411//----------------------------------------------------------------------
4412
4414{
4415 AUTO_TRACE();
4416 for (const auto &[qualifiedName,bodyInfo] : Doxygen::staticInitMap)
4417 {
4418 size_t i=qualifiedName.rfind("::");
4419 if (i!=std::string::npos)
4420 {
4421 QCString scope = qualifiedName.substr(0,i);
4422 QCString name = qualifiedName.substr(i+2);
4423 MemberName *mn = Doxygen::memberNameLinkedMap->find(name);
4424 if (mn)
4425 {
4426 for (const auto &imd : *mn)
4427 {
4428 MemberDefMutable *md = toMemberDefMutable(imd.get());
4429 if (md && md->qualifiedName().str()==qualifiedName && md->isVariable())
4430 {
4431 AUTO_TRACE_ADD("found static member {} body [{}..{}]\n",
4432 md->qualifiedName(),bodyInfo.startLine,bodyInfo.endLine);
4433 md->setBodySegment(bodyInfo.defLine,
4434 bodyInfo.startLine,
4435 bodyInfo.endLine);
4436 }
4437 }
4438 }
4439 }
4440 }
4441}
4442
4443//----------------------------------------------------------------------
4444
4445/*! make a dictionary of all template arguments of class cd
4446 * that are part of the base class name.
4447 * Example: A template class A with template arguments <R,S,T>
4448 * that inherits from B<T,T,S> will have T and S in the dictionary.
4449 */
4450static TemplateNameMap getTemplateArgumentsInName(const ArgumentList &templateArguments,const std::string &name)
4451{
4452 std::map<std::string,int> templateNames;
4453 int count=0;
4454 for (const Argument &arg : templateArguments)
4455 {
4456 static const reg::Ex re(R"(\a[\w:]*)");
4457 reg::Iterator it(name,re);
4459 for (; it!=end ; ++it)
4460 {
4461 const auto &match = *it;
4462 std::string n = match.str();
4463 if (n==arg.name.str())
4464 {
4465 if (templateNames.find(n)==templateNames.end())
4466 {
4467 templateNames.emplace(n,count);
4468 }
4469 }
4470 }
4471 }
4472 return templateNames;
4473}
4474
4475/*! Searches a class from within \a context and \a cd and returns its
4476 * definition if found (otherwise nullptr is returned).
4477 */
4479{
4480 ClassDef *result=nullptr;
4481 if (cd==nullptr)
4482 {
4483 return result;
4484 }
4485 FileDef *fd=cd->getFileDef();
4486 SymbolResolver resolver(fd);
4487 if (context && cd!=context)
4488 {
4489 result = const_cast<ClassDef*>(resolver.resolveClass(context,name,true,true));
4490 }
4491 //printf("1. result=%p\n",result);
4492 if (result==nullptr)
4493 {
4494 result = const_cast<ClassDef*>(resolver.resolveClass(cd,name,true,true));
4495 }
4496 //printf("2. result=%p\n",result);
4497 if (result==nullptr) // try direct class, needed for namespaced classes imported via tag files (see bug624095)
4498 {
4499 result = getClass(name);
4500 }
4501 //printf("3. result=%p\n",result);
4502 //printf("** Trying to find %s within context %s class %s result=%s lookup=%p\n",
4503 // qPrint(name),
4504 // context ? qPrint(context->name()) : "<none>",
4505 // cd ? qPrint(cd->name()) : "<none>",
4506 // result ? qPrint(result->name()) : "<none>",
4507 // Doxygen::classLinkedMap->find(name)
4508 // );
4509 return result;
4510}
4511
4512
4513static void findUsedClassesForClass(const Entry *root,
4514 Definition *context,
4515 ClassDefMutable *masterCd,
4516 ClassDefMutable *instanceCd,
4517 bool isArtificial,
4518 const ArgumentList *actualArgs = nullptr,
4519 const TemplateNameMap &templateNames = TemplateNameMap()
4520 )
4521{
4522 AUTO_TRACE();
4523 const ArgumentList &formalArgs = masterCd->templateArguments();
4524 for (auto &mni : masterCd->memberNameInfoLinkedMap())
4525 {
4526 for (auto &mi : *mni)
4527 {
4528 const MemberDef *md=mi->memberDef();
4529 if (md->isVariable() || md->isObjCProperty()) // for each member variable in this class
4530 {
4531 AUTO_TRACE_ADD("Found variable '{}' in class '{}'",md->name(),masterCd->name());
4532 QCString type = normalizeNonTemplateArgumentsInString(md->typeString(),masterCd,formalArgs);
4533 QCString typedefValue = md->getLanguage()==SrcLangExt::Java ? type : resolveTypeDef(masterCd,type);
4534 if (!typedefValue.isEmpty())
4535 {
4536 type = typedefValue;
4537 }
4538 int pos=0;
4539 QCString usedClassName;
4540 QCString templSpec;
4541 bool found=FALSE;
4542 // the type can contain template variables, replace them if present
4543 type = substituteTemplateArgumentsInString(type,formalArgs,actualArgs);
4544
4545 //printf(" template substitution gives=%s\n",qPrint(type));
4546 while (!found && extractClassNameFromType(type,pos,usedClassName,templSpec,root->lang)!=-1)
4547 {
4548 // find the type (if any) that matches usedClassName
4549 SymbolResolver resolver(masterCd->getFileDef());
4550 const ClassDefMutable *typeCd = resolver.resolveClassMutable(masterCd,usedClassName,false,true);
4551 //printf("====> usedClassName=%s -> typeCd=%s\n",
4552 // qPrint(usedClassName),typeCd?qPrint(typeCd->name()):"<none>");
4553 if (typeCd)
4554 {
4555 usedClassName = typeCd->name();
4556 }
4557
4558 int sp=usedClassName.find('<');
4559 if (sp==-1) sp=0;
4560 // replace any namespace aliases
4561 replaceNamespaceAliases(usedClassName);
4562 // add any template arguments to the class
4563 QCString usedName = removeRedundantWhiteSpace(usedClassName+templSpec);
4564 //printf(" usedName=%s usedClassName=%s templSpec=%s\n",qPrint(usedName),qPrint(usedClassName),qPrint(templSpec));
4565
4566 TemplateNameMap formTemplateNames;
4567 if (templateNames.empty())
4568 {
4569 formTemplateNames = getTemplateArgumentsInName(formalArgs,usedName.str());
4570 }
4571 BaseInfo bi(usedName,Protection::Public,Specifier::Normal);
4572 findClassRelation(root,context,instanceCd,&bi,formTemplateNames,TemplateInstances,isArtificial);
4573
4574 for (const Argument &arg : masterCd->templateArguments())
4575 {
4576 if (arg.name==usedName) // type is a template argument
4577 {
4578 ClassDef *usedCd = Doxygen::hiddenClassLinkedMap->find(usedName);
4579 ClassDefMutable *usedCdm = toClassDefMutable(usedCd);
4580 if (usedCd==nullptr)
4581 {
4582 usedCdm = toClassDefMutable(
4583 Doxygen::hiddenClassLinkedMap->add(usedName,
4585 masterCd->getDefFileName(),masterCd->getDefLine(),
4586 masterCd->getDefColumn(),
4587 usedName,
4588 ClassDef::Class)));
4589 if (usedCdm)
4590 {
4591 //printf("making %s a template argument!!!\n",qPrint(usedCd->name()));
4592 usedCdm->makeTemplateArgument();
4593 usedCdm->setUsedOnly(TRUE);
4594 usedCdm->setLanguage(masterCd->getLanguage());
4595 usedCd = usedCdm;
4596 }
4597 }
4598 if (usedCd)
4599 {
4600 found=TRUE;
4601 AUTO_TRACE_ADD("case 1: adding used class '{}'", usedCd->name());
4602 instanceCd->addUsedClass(usedCd,md->name(),md->protection());
4603 if (usedCdm)
4604 {
4605 if (isArtificial) usedCdm->setArtificial(TRUE);
4606 usedCdm->addUsedByClass(instanceCd,md->name(),md->protection());
4607 }
4608 }
4609 }
4610 }
4611
4612 if (!found)
4613 {
4614 ClassDef *usedCd=findClassWithinClassContext(context,masterCd,usedName);
4615 //printf("Looking for used class %s: result=%s master=%s\n",
4616 // qPrint(usedName),usedCd?qPrint(usedCd->name()):"<none>",masterCd?qPrint(masterCd->name()):"<none>");
4617
4618 if (usedCd)
4619 {
4620 found=TRUE;
4621 AUTO_TRACE_ADD("case 2: adding used class '{}'", usedCd->name());
4622 instanceCd->addUsedClass(usedCd,md->name(),md->protection()); // class exists
4623 ClassDefMutable *usedCdm = toClassDefMutable(usedCd);
4624 if (usedCdm)
4625 {
4626 usedCdm->addUsedByClass(instanceCd,md->name(),md->protection());
4627 }
4628 }
4629 }
4630 }
4631 if (!found && !type.isEmpty()) // used class is not documented in any scope
4632 {
4633 ClassDef *usedCd = Doxygen::hiddenClassLinkedMap->find(type);
4634 ClassDefMutable *usedCdm = toClassDefMutable(usedCd);
4635 if (usedCd==nullptr && !Config_getBool(HIDE_UNDOC_RELATIONS))
4636 {
4637 if (type.endsWith("(*") || type.endsWith("(^")) // type is a function pointer
4638 {
4639 type+=md->argsString();
4640 }
4641 AUTO_TRACE_ADD("New undocumented used class '{}'", type);
4642 usedCdm = toClassDefMutable(
4645 masterCd->getDefFileName(),masterCd->getDefLine(),
4646 masterCd->getDefColumn(),
4647 type,ClassDef::Class)));
4648 if (usedCdm)
4649 {
4650 usedCdm->setUsedOnly(TRUE);
4651 usedCdm->setLanguage(masterCd->getLanguage());
4652 usedCd = usedCdm;
4653 }
4654 }
4655 if (usedCd)
4656 {
4657 AUTO_TRACE_ADD("case 3: adding used class '{}'", usedCd->name());
4658 instanceCd->addUsedClass(usedCd,md->name(),md->protection());
4659 if (usedCdm)
4660 {
4661 if (isArtificial) usedCdm->setArtificial(TRUE);
4662 usedCdm->addUsedByClass(instanceCd,md->name(),md->protection());
4663 }
4664 }
4665 }
4666 }
4667 }
4668 }
4669}
4670
4672 const Entry *root,
4673 Definition *context,
4674 ClassDefMutable *masterCd,
4675 ClassDefMutable *instanceCd,
4677 bool isArtificial,
4678 const ArgumentList *actualArgs = nullptr,
4679 const TemplateNameMap &templateNames=TemplateNameMap()
4680 )
4681{
4682 AUTO_TRACE("name={}",root->name);
4683 // The base class could ofcouse also be a non-nested class
4684 const ArgumentList &formalArgs = masterCd->templateArguments();
4685 for (const BaseInfo &bi : root->extends)
4686 {
4687 //printf("masterCd=%s bi.name='%s' #actualArgs=%d\n",
4688 // qPrint(masterCd->localName()),qPrint(bi.name),actualArgs ? (int)actualArgs->size() : -1);
4689 TemplateNameMap formTemplateNames;
4690 if (templateNames.empty())
4691 {
4692 formTemplateNames = getTemplateArgumentsInName(formalArgs,bi.name.str());
4693 }
4694 BaseInfo tbi = bi;
4695 tbi.name = substituteTemplateArgumentsInString(bi.name,formalArgs,actualArgs);
4696 //printf("masterCd=%p instanceCd=%p bi->name=%s tbi.name=%s\n",(void*)masterCd,(void*)instanceCd,qPrint(bi.name),qPrint(tbi.name));
4697
4698 if (mode==DocumentedOnly)
4699 {
4700 // find a documented base class in the correct scope
4701 if (!findClassRelation(root,context,instanceCd,&tbi,formTemplateNames,DocumentedOnly,isArtificial))
4702 {
4703 // 1.8.2: decided to show inheritance relations even if not documented,
4704 // we do make them artificial, so they do not appear in the index
4705 //if (!Config_getBool(HIDE_UNDOC_RELATIONS))
4706 bool b = Config_getBool(HIDE_UNDOC_RELATIONS) ? TRUE : isArtificial;
4707 //{
4708 // no documented base class -> try to find an undocumented one
4709 findClassRelation(root,context,instanceCd,&tbi,formTemplateNames,Undocumented,b);
4710 //}
4711 }
4712 }
4713 else if (mode==TemplateInstances)
4714 {
4715 findClassRelation(root,context,instanceCd,&tbi,formTemplateNames,TemplateInstances,isArtificial);
4716 }
4717 }
4718}
4719
4720//----------------------------------------------------------------------
4721
4722static void findTemplateInstanceRelation(const Entry *root,
4723 Definition *context,
4724 ClassDefMutable *templateClass,const QCString &templSpec,
4725 const TemplateNameMap &templateNames,
4726 bool isArtificial)
4727{
4728 AUTO_TRACE("Derived from template '{}' with parameters '{}' isArtificial={}",
4729 templateClass->name(),templSpec,isArtificial);
4730
4731 QCString tempArgsStr = tempArgListToString(templateClass->templateArguments(),root->lang,false);
4732 bool existingClass = templSpec==tempArgsStr;
4733 if (existingClass) return; // avoid recursion
4734
4735 bool freshInstance=FALSE;
4736 ClassDefMutable *instanceClass = toClassDefMutable(
4737 templateClass->insertTemplateInstance(
4738 root->fileName,root->startLine,root->startColumn,templSpec,freshInstance));
4739 if (instanceClass)
4740 {
4741 instanceClass->setArtificial(TRUE);
4742 instanceClass->setLanguage(root->lang);
4743
4744 if (freshInstance)
4745 {
4746 AUTO_TRACE_ADD("found fresh instance '{}'",instanceClass->name());
4747 instanceClass->setTemplateBaseClassNames(templateNames);
4748
4749 // search for new template instances caused by base classes of
4750 // instanceClass
4751 auto it_pair = g_classEntries.equal_range(templateClass->name().str());
4752 for (auto it=it_pair.first ; it!=it_pair.second ; ++it)
4753 {
4754 const Entry *templateRoot = it->second;
4755 AUTO_TRACE_ADD("template root found '{}' templSpec='{}'",templateRoot->name,templSpec);
4756 std::unique_ptr<ArgumentList> templArgs = stringToArgumentList(root->lang,templSpec);
4757 findBaseClassesForClass(templateRoot,context,templateClass,instanceClass,
4758 TemplateInstances,isArtificial,templArgs.get(),templateNames);
4759
4760 findUsedClassesForClass(templateRoot,context,templateClass,instanceClass,
4761 isArtificial,templArgs.get(),templateNames);
4762 }
4763 }
4764 else
4765 {
4766 AUTO_TRACE_ADD("instance already exists");
4767 }
4768 }
4769}
4770
4771//----------------------------------------------------------------------
4772
4773static void resolveTemplateInstanceInType(const Entry *root,const Definition *scope,const MemberDef *md)
4774{
4775 // For a statement like 'using X = T<A>', add a template instance 'T<A>' as a symbol, so it can
4776 // be used to match arguments (see issue #11111)
4777 AUTO_TRACE();
4778 QCString ttype = md->typeString();
4779 ttype.stripPrefix("typedef ");
4780 int ti=ttype.find('<');
4781 if (ti!=-1)
4782 {
4783 QCString templateClassName = ttype.left(ti);
4784 SymbolResolver resolver(root->fileDef());
4785 ClassDefMutable *baseClass = resolver.resolveClassMutable(scope ? scope : Doxygen::globalScope,
4786 templateClassName, true, true);
4787 AUTO_TRACE_ADD("templateClassName={} baseClass={}",templateClassName,baseClass?baseClass->name():"<none>");
4788 if (baseClass)
4789 {
4790 const ArgumentList &tl = baseClass->templateArguments();
4791 TemplateNameMap templateNames = getTemplateArgumentsInName(tl,templateClassName.str());
4793 baseClass,
4794 ttype.mid(ti),
4795 templateNames,
4796 baseClass->isArtificial());
4797 }
4798 }
4799}
4800
4801//----------------------------------------------------------------------
4802
4803static bool isRecursiveBaseClass(const QCString &scope,const QCString &name)
4804{
4805 QCString n=name;
4806 int index=n.find('<');
4807 if (index!=-1)
4808 {
4809 n=n.left(index);
4810 }
4811 bool result = rightScopeMatch(scope,n);
4812 return result;
4813}
4814
4816{
4817 if (name.isEmpty()) return 0;
4818 int l = static_cast<int>(name.length());
4819 if (name[l-1]=='>') // search backward to find the matching <, allowing nested <...> and strings.
4820 {
4821 int count=1;
4822 int i=l-2;
4823 char insideQuote=0;
4824 while (count>0 && i>=0)
4825 {
4826 char c = name[i--];
4827 switch (c)
4828 {
4829 case '>': if (!insideQuote) count++; break;
4830 case '<': if (!insideQuote) count--; break;
4831 case '\'': if (!insideQuote) insideQuote=c;
4832 else if (insideQuote==c && (i<0 || name[i]!='\\')) insideQuote=0;
4833 break;
4834 case '"': if (!insideQuote) insideQuote=c;
4835 else if (insideQuote==c && (i<0 || name[i]!='\\')) insideQuote=0;
4836 break;
4837 default: break;
4838 }
4839 }
4840 if (i>=0) l=i+1;
4841 }
4842 return l;
4843}
4844
4846 const Entry *root,
4847 Definition *context,
4848 ClassDefMutable *cd,
4849 const BaseInfo *bi,
4850 const TemplateNameMap &templateNames,
4852 bool isArtificial
4853 )
4854{
4855 AUTO_TRACE("name={} base={} isArtificial={} mode={}",cd->name(),bi->name,isArtificial,(int)mode);
4856
4857 QCString biName=bi->name;
4858 bool explicitGlobalScope=FALSE;
4859 if (biName.startsWith("::")) // explicit global scope
4860 {
4861 biName=biName.right(biName.length()-2);
4862 explicitGlobalScope=TRUE;
4863 }
4864
4865 Entry *parentNode=root->parent();
4866 bool lastParent=FALSE;
4867 do // for each parent scope, starting with the largest scope
4868 // (in case of nested classes)
4869 {
4870 QCString scopeName= parentNode ? parentNode->name : QCString();
4871 int scopeOffset=explicitGlobalScope ? 0 : static_cast<int>(scopeName.length());
4872 do // try all parent scope prefixes, starting with the largest scope
4873 {
4874 //printf("scopePrefix='%s' biName='%s'\n",
4875 // qPrint(scopeName.left(scopeOffset)),qPrint(biName));
4876
4877 QCString baseClassName=biName;
4878 if (scopeOffset>0)
4879 {
4880 baseClassName.prepend(scopeName.left(scopeOffset)+"::");
4881 }
4882 if (root->lang==SrcLangExt::CSharp)
4883 {
4884 baseClassName = mangleCSharpGenericName(baseClassName);
4885 }
4886 AUTO_TRACE_ADD("cd='{}' baseClassName='{}'",cd->name(),baseClassName);
4887 SymbolResolver resolver(cd->getFileDef());
4888 ClassDefMutable *baseClass = resolver.resolveClassMutable(explicitGlobalScope ? Doxygen::globalScope : context,
4889 baseClassName,
4890 mode==Undocumented,
4891 true
4892 );
4893 const MemberDef *baseClassTypeDef = resolver.getTypedef();
4894 QCString templSpec = resolver.getTemplateSpec();
4895 //printf("baseClassName=%s baseClass=%p cd=%p explicitGlobalScope=%d\n",
4896 // qPrint(baseClassName),baseClass,cd,explicitGlobalScope);
4897 //printf(" scope='%s' baseClassName='%s' baseClass=%s templSpec=%s\n",
4898 // cd ? qPrint(cd->name()):"<none>",
4899 // qPrint(baseClassName),
4900 // baseClass?qPrint(baseClass->name()):"<none>",
4901 // qPrint(templSpec)
4902 // );
4903 //if (baseClassName.left(root->name.length())!=root->name ||
4904 // baseClassName.at(root->name.length())!='<'
4905 // ) // Check for base class with the same name.
4906 // // If found then look in the outer scope for a match
4907 // // and prevent recursion.
4908 if (!isRecursiveBaseClass(root->name,baseClassName)
4909 || explicitGlobalScope
4910 // sadly isRecursiveBaseClass always true for UNO IDL ifc/svc members
4911 // (i.e. this is needed for addInterfaceOrServiceToServiceOrSingleton)
4912 || (root->lang==SrcLangExt::IDL &&
4913 (root->section.isExportedInterface() ||
4914 root->section.isIncludedService()))
4915 )
4916 {
4917 AUTO_TRACE_ADD("class relation '{}' inherited/used by '{}' found prot={} virt={} templSpec='{}'",
4918 baseClassName, root->name, bi->prot, bi->virt, templSpec);
4919
4920 int i=findTemplateSpecializationPosition(baseClassName);
4921 int si=baseClassName.findRev("::",i);
4922 if (si==-1) si=0;
4923 if (baseClass==nullptr && static_cast<size_t>(i)!=baseClassName.length())
4924 // base class has template specifiers
4925 {
4926 // TODO: here we should try to find the correct template specialization
4927 // but for now, we only look for the unspecialized base class.
4928 int e=findEndOfTemplate(baseClassName,i+1);
4929 //printf("baseClass==0 i=%d e=%d\n",i,e);
4930 if (e!=-1) // end of template was found at e
4931 {
4932 templSpec = removeRedundantWhiteSpace(baseClassName.mid(i,e-i));
4933 baseClassName = baseClassName.left(i)+baseClassName.right(baseClassName.length()-e);
4934 baseClass = resolver.resolveClassMutable(explicitGlobalScope ? Doxygen::globalScope : context,
4935 baseClassName,
4936 mode==Undocumented,
4937 true
4938 );
4939 baseClassTypeDef = resolver.getTypedef();
4940 //printf("baseClass=%p -> baseClass=%s templSpec=%s\n",
4941 // baseClass,qPrint(baseClassName),qPrint(templSpec));
4942 }
4943 }
4944 else if (baseClass && !templSpec.isEmpty()) // we have a known class, but also
4945 // know it is a template, so see if
4946 // we can also link to the explicit
4947 // instance (for instance if a class
4948 // derived from a template argument)
4949 {
4950 //printf("baseClass=%s templSpec=%s\n",qPrint(baseClass->name()),qPrint(templSpec));
4951 ClassDefMutable *templClass=getClassMutable(baseClass->name()+templSpec);
4952 if (templClass)
4953 {
4954 // use the template instance instead of the template base.
4955 baseClass = templClass;
4956 templSpec.clear();
4957 }
4958 }
4959
4960 //printf("cd=%p baseClass=%p\n",cd,baseClass);
4961 bool found=baseClass!=nullptr && (baseClass!=cd || mode==TemplateInstances);
4962 AUTO_TRACE_ADD("1. found={}",found);
4963 if (!found && si!=-1)
4964 {
4965 // replace any namespace aliases
4966 replaceNamespaceAliases(baseClassName);
4967 baseClass = resolver.resolveClassMutable(explicitGlobalScope ? Doxygen::globalScope : context,
4968 baseClassName,
4969 mode==Undocumented,
4970 true
4971 );
4972 baseClassTypeDef = resolver.getTypedef();
4973 found=baseClass!=nullptr && baseClass!=cd;
4974 if (found) templSpec = resolver.getTemplateSpec();
4975 }
4976 AUTO_TRACE_ADD("2. found={}",found);
4977
4978 if (!found)
4979 {
4980 baseClass=toClassDefMutable(findClassWithinClassContext(context,cd,baseClassName));
4981 //printf("findClassWithinClassContext(%s,%s)=%p\n",
4982 // qPrint(cd->name()),qPrint(baseClassName),baseClass);
4983 found = baseClass!=nullptr && baseClass!=cd;
4984
4985 }
4986 AUTO_TRACE_ADD("3. found={}",found);
4987 if (!found)
4988 {
4989 // for PHP the "use A\B as C" construct map class C to A::B, so we lookup
4990 // the class name also in the alias mapping.
4991 auto it = Doxygen::namespaceAliasMap.find(baseClassName.str());
4992 if (it!=Doxygen::namespaceAliasMap.end()) // see if it is indeed a class.
4993 {
4994 baseClass=getClassMutable(QCString(it->second.alias));
4995 found = baseClass!=nullptr && baseClass!=cd;
4996 }
4997 }
4998 bool isATemplateArgument = templateNames.find(biName.str())!=templateNames.end();
4999
5000 AUTO_TRACE_ADD("4. found={}",found);
5001 if (found)
5002 {
5003 AUTO_TRACE_ADD("Documented base class '{}' templSpec='{}'",biName,templSpec);
5004 // add base class to this class
5005
5006 // if templSpec is not empty then we should "instantiate"
5007 // the template baseClass. A new ClassDef should be created
5008 // to represent the instance. To be able to add the (instantiated)
5009 // members and documentation of a template class
5010 // (inserted in that template class at a later stage),
5011 // the template should know about its instances.
5012 // the instantiation process, should be done in a recursive way,
5013 // since instantiating a template may introduce new inheritance
5014 // relations.
5015 if (!templSpec.isEmpty() && mode==TemplateInstances)
5016 {
5017 // if baseClass is actually a typedef then we should not
5018 // instantiate it, since typedefs are in a different namespace
5019 // see bug531637 for an example where this would otherwise hang
5020 // Doxygen
5021 if (baseClassTypeDef==nullptr)
5022 {
5023 //printf(" => findTemplateInstanceRelation: %s\n",qPrint(baseClass->name()));
5024 findTemplateInstanceRelation(root,context,baseClass,templSpec,templateNames,baseClass->isArtificial());
5025 }
5026 }
5027 else if (mode==DocumentedOnly || mode==Undocumented)
5028 {
5029 //printf(" => insert base class\n");
5030 QCString usedName;
5031 if (baseClassTypeDef)
5032 {
5033 usedName=biName;
5034 //printf("***** usedName=%s templSpec=%s\n",qPrint(usedName),qPrint(templSpec));
5035 }
5036 Protection prot = bi->prot;
5037 if (Config_getBool(SIP_SUPPORT)) prot=Protection::Public;
5038 if (cd!=baseClass && !cd->isSubClass(baseClass) && baseClass->isBaseClass(cd,true,templSpec)==0) // check for recursion, see bug690787
5039 {
5040 AUTO_TRACE_ADD("insertBaseClass name={} prot={} virt={} templSpec={}",usedName,prot,bi->virt,templSpec);
5041 cd->insertBaseClass(baseClass,usedName,prot,bi->virt,templSpec);
5042 // add this class as super class to the base class
5043 baseClass->insertSubClass(cd,prot,bi->virt,templSpec);
5044 }
5045 else
5046 {
5047 warn(root->fileName,root->startLine,
5048 "Detected potential recursive class relation "
5049 "between class {} and base class {}!",
5050 cd->name(),baseClass->name()
5051 );
5052 }
5053 }
5054 return TRUE;
5055 }
5056 else if (mode==Undocumented && (scopeOffset==0 || isATemplateArgument))
5057 {
5058 AUTO_TRACE_ADD("New undocumented base class '{}' baseClassName='{}' templSpec='{}' isArtificial={}",
5059 biName,baseClassName,templSpec,isArtificial);
5060 baseClass=nullptr;
5061 if (isATemplateArgument)
5062 {
5063 baseClass = toClassDefMutable(Doxygen::hiddenClassLinkedMap->find(baseClassName));
5064 if (baseClass==nullptr) // not found (or alias)
5065 {
5066 baseClass= toClassDefMutable(
5067 Doxygen::hiddenClassLinkedMap->add(baseClassName,
5068 createClassDef(root->fileName,root->startLine,root->startColumn,
5069 baseClassName,
5070 ClassDef::Class)));
5071 if (baseClass) // really added (not alias)
5072 {
5073 if (isArtificial) baseClass->setArtificial(TRUE);
5074 baseClass->setLanguage(root->lang);
5075 }
5076 }
5077 }
5078 else
5079 {
5080 baseClass = toClassDefMutable(Doxygen::classLinkedMap->find(baseClassName));
5081 //printf("*** classDDict->find(%s)=%p biName=%s templSpec=%s\n",
5082 // qPrint(baseClassName),baseClass,qPrint(biName),qPrint(templSpec));
5083 if (baseClass==nullptr) // not found (or alias)
5084 {
5085 baseClass = toClassDefMutable(
5086 Doxygen::classLinkedMap->add(baseClassName,
5087 createClassDef(root->fileName,root->startLine,root->startColumn,
5088 baseClassName,
5089 ClassDef::Class)));
5090 if (baseClass) // really added (not alias)
5091 {
5092 if (isArtificial) baseClass->setArtificial(TRUE);
5093 baseClass->setLanguage(root->lang);
5094 si = baseClassName.findRev("::");
5095 if (si!=-1) // class is nested
5096 {
5097 Definition *sd = findScopeFromQualifiedName(Doxygen::globalScope,baseClassName.left(si),nullptr,root->tagInfo());
5098 if (sd==nullptr || sd==Doxygen::globalScope) // outer scope not found
5099 {
5100 baseClass->setArtificial(TRUE); // see bug678139
5101 }
5102 }
5103 }
5104 }
5105 }
5106 if (baseClass)
5107 {
5108 if (biName.endsWith("-p"))
5109 {
5110 biName="<"+biName.left(biName.length()-2)+">";
5111 }
5112 if (!cd->isSubClass(baseClass) && cd!=baseClass && cd->isBaseClass(baseClass,true,templSpec)==0) // check for recursion
5113 {
5114 AUTO_TRACE_ADD("insertBaseClass name={} prot={} virt={} templSpec={}",biName,bi->prot,bi->virt,templSpec);
5115 // add base class to this class
5116 cd->insertBaseClass(baseClass,biName,bi->prot,bi->virt,templSpec);
5117 // add this class as super class to the base class
5118 baseClass->insertSubClass(cd,bi->prot,bi->virt,templSpec);
5119 }
5120 // the undocumented base was found in this file
5121 baseClass->insertUsedFile(root->fileDef());
5122
5123 Definition *scope = buildScopeFromQualifiedName(baseClass->name(),root->lang,nullptr);
5124 if (scope!=baseClass)
5125 {
5126 baseClass->setOuterScope(scope);
5127 }
5128
5129 if (baseClassName.endsWith("-p"))
5130 {
5132 }
5133 return TRUE;
5134 }
5135 else
5136 {
5137 AUTO_TRACE_ADD("Base class '{}' not created (alias?)",biName);
5138 }
5139 }
5140 else
5141 {
5142 AUTO_TRACE_ADD("Base class '{}' not found",biName);
5143 }
5144 }
5145 else
5146 {
5147 if (mode!=TemplateInstances)
5148 {
5149 warn(root->fileName,root->startLine,
5150 "Detected potential recursive class relation "
5151 "between class {} and base class {}!",
5152 root->name,baseClassName
5153 );
5154 }
5155 // for mode==TemplateInstance this case is quite common and
5156 // indicates a relation between a template class and a template
5157 // instance with the same name.
5158 }
5159 if (scopeOffset==0)
5160 {
5161 scopeOffset=-1;
5162 }
5163 else if ((scopeOffset=scopeName.findRev("::",scopeOffset-1))==-1)
5164 {
5165 scopeOffset=0;
5166 }
5167 //printf("new scopeOffset='%d'",scopeOffset);
5168 } while (scopeOffset>=0);
5169
5170 if (parentNode==nullptr)
5171 {
5172 lastParent=TRUE;
5173 }
5174 else
5175 {
5176 parentNode=parentNode->parent();
5177 }
5178 } while (lastParent);
5179
5180 return FALSE;
5181}
5182
5183//----------------------------------------------------------------------
5184// Computes the base and super classes for each class in the tree
5185
5186static bool isClassSection(const Entry *root)
5187{
5188 if ( !root->name.isEmpty() )
5189 {
5190 if (root->section.isCompound())
5191 // is it a compound (class, struct, union, interface ...)
5192 {
5193 return TRUE;
5194 }
5195 else if (root->section.isCompoundDoc())
5196 // is it a documentation block with inheritance info.
5197 {
5198 bool hasExtends = !root->extends.empty();
5199 if (hasExtends) return TRUE;
5200 }
5201 }
5202 return FALSE;
5203}
5204
5205
5206/*! Builds a dictionary of all entry nodes in the tree starting with \a root
5207 */
5208static void findClassEntries(const Entry *root)
5209{
5210 if (isClassSection(root))
5211 {
5212 g_classEntries.emplace(root->name.str(),root);
5213 }
5214 for (const auto &e : root->children()) findClassEntries(e.get());
5215}
5216
5218{
5219 // strip any anonymous scopes first
5222 int i=0;
5223 if ((root->lang==SrcLangExt::CSharp || root->lang==SrcLangExt::Java) &&
5224 (i=bName.find('<'))!=-1)
5225 {
5226 // a Java/C# generic class looks like a C++ specialization, so we need to strip the
5227 // template part before looking for matches
5228 if (root->lang==SrcLangExt::CSharp)
5229 {
5230 bName = mangleCSharpGenericName(root->name);
5231 }
5232 else
5233 {
5234 bName = bName.left(i);
5235 }
5236 }
5237 return bName;
5238}
5239
5240/*! Using the dictionary build by findClassEntries(), this
5241 * function will look for additional template specialization that
5242 * exists as inheritance relations only. These instances will be
5243 * added to the template they are derived from.
5244 */
5246{
5247 AUTO_TRACE();
5248 ClassDefSet visitedClasses;
5249 for (const auto &[name,root] : g_classEntries)
5250 {
5251 QCString bName = extractClassName(root);
5252 ClassDefMutable *cdm = getClassMutable(bName);
5253 if (cdm)
5254 {
5256 }
5257 }
5258}
5259
5261{
5262 AUTO_TRACE("root->name={} cd={}",root->name,cd->name());
5263 int i = root->name.find('<');
5264 int j = root->name.findRev('>');
5265 int k = root->name.find("::",j+1); // A<T::B> => ok, A<T>::B => nok
5266 if (i!=-1 && j!=-1 && k==-1 && root->lang!=SrcLangExt::CSharp && root->lang!=SrcLangExt::Java)
5267 {
5268 ClassDefMutable *master = getClassMutable(root->name.left(i));
5269 if (master && master!=cd && !cd->templateMaster())
5270 {
5271 AUTO_TRACE_ADD("class={} master={}",cd->name(),cd->templateMaster()?cd->templateMaster()->name():"<none>",master->name());
5272 cd->setTemplateMaster(master);
5273 master->insertExplicitTemplateInstance(cd,root->name.mid(i));
5274 }
5275 }
5276}
5277
5279{
5280 AUTO_TRACE();
5281 for (const auto &[name,root] : g_classEntries)
5282 {
5283 QCString bName = extractClassName(root);
5284 ClassDefMutable *cdm = getClassMutable(bName);
5285 if (cdm)
5286 {
5287 findUsedClassesForClass(root,cdm,cdm,cdm,TRUE);
5289 cdm->addTypeConstraints();
5290 }
5291 }
5292}
5293
5295{
5296 AUTO_TRACE();
5297 for (const auto &nd : *Doxygen::namespaceLinkedMap)
5298 {
5299 if (!nd->hasDocumentation())
5300 {
5301 if ((guessSection(nd->getDefFileName()).isHeader() ||
5302 nd->getLanguage() == SrcLangExt::Fortran) && // Fortran doesn't have header files.
5303 !Config_getBool(HIDE_UNDOC_NAMESPACES) // undocumented namespaces are visible
5304 )
5305 {
5306 warn_undoc(nd->getDefFileName(),nd->getDefLine(), "{} {} is not documented.",
5307 nd->getLanguage() == SrcLangExt::Fortran ? "Module" : "Namespace",
5308 nd->name());
5309 }
5310 }
5311 }
5312}
5313
5315{
5316 AUTO_TRACE();
5317 for (const auto &[name,root] : g_classEntries)
5318 {
5319 QCString bName = extractClassName(root);
5320 ClassDefMutable *cd = getClassMutable(bName);
5321 if (cd)
5322 {
5324 }
5325 size_t numMembers = cd ? cd->memberNameInfoLinkedMap().size() : 0;
5326 if ((cd==nullptr || (!cd->hasDocumentation() && !cd->isReference())) && numMembers>0 && !bName.endsWith("::"))
5327 {
5328 if (!root->name.isEmpty() && root->name.find('@')==-1 && // normal name
5329 (guessSection(root->fileName).isHeader() ||
5330 Config_getBool(EXTRACT_LOCAL_CLASSES)) && // not defined in source file
5331 protectionLevelVisible(root->protection) && // hidden by protection
5332 !Config_getBool(HIDE_UNDOC_CLASSES) // undocumented class are visible
5333 )
5334 warn_undoc(root->fileName,root->startLine, "Compound {} is not documented.", root->name);
5335 }
5336 }
5337}
5338
5340{
5341 AUTO_TRACE();
5342 for (const auto &[name,root] : g_classEntries)
5343 {
5347 // strip any anonymous scopes first
5348 if (cd && !cd->getTemplateInstances().empty())
5349 {
5350 AUTO_TRACE_ADD("Template class '{}'",cd->name());
5351 for (const auto &ti : cd->getTemplateInstances()) // for each template instance
5352 {
5353 ClassDefMutable *tcd=toClassDefMutable(ti.classDef);
5354 if (tcd)
5355 {
5356 AUTO_TRACE_ADD("Template instance '{}'",tcd->name());
5357 QCString templSpec = ti.templSpec;
5358 std::unique_ptr<ArgumentList> templArgs = stringToArgumentList(tcd->getLanguage(),templSpec);
5359 for (const BaseInfo &bi : root->extends)
5360 {
5361 // check if the base class is a template argument
5362 BaseInfo tbi = bi;
5363 const ArgumentList &tl = cd->templateArguments();
5364 if (!tl.empty())
5365 {
5366 TemplateNameMap baseClassNames = tcd->getTemplateBaseClassNames();
5367 TemplateNameMap templateNames = getTemplateArgumentsInName(tl,bi.name.str());
5368 // for each template name that we inherit from we need to
5369 // substitute the formal with the actual arguments
5370 TemplateNameMap actualTemplateNames;
5371 for (const auto &tn_kv : templateNames)
5372 {
5373 size_t templIndex = tn_kv.second;
5374 Argument actArg;
5375 bool hasActArg=FALSE;
5376 if (templIndex<templArgs->size())
5377 {
5378 actArg=templArgs->at(templIndex);
5379 hasActArg=TRUE;
5380 }
5381 if (hasActArg &&
5382 baseClassNames.find(actArg.type.str())!=baseClassNames.end() &&
5383 actualTemplateNames.find(actArg.type.str())==actualTemplateNames.end()
5384 )
5385 {
5386 actualTemplateNames.emplace(actArg.type.str(),static_cast<int>(templIndex));
5387 }
5388 }
5389
5390 tbi.name = substituteTemplateArgumentsInString(bi.name,tl,templArgs.get());
5391 // find a documented base class in the correct scope
5392 if (!findClassRelation(root,cd,tcd,&tbi,actualTemplateNames,DocumentedOnly,FALSE))
5393 {
5394 // no documented base class -> try to find an undocumented one
5395 findClassRelation(root,cd,tcd,&tbi,actualTemplateNames,Undocumented,TRUE);
5396 }
5397 }
5398 }
5399 }
5400 }
5401 }
5402 }
5403}
5404
5405//-----------------------------------------------------------------------
5406// compute the references (anchors in HTML) for each function in the file
5407
5409{
5410 AUTO_TRACE();
5411 for (const auto &cd : *Doxygen::classLinkedMap)
5412 {
5413 ClassDefMutable *cdm = toClassDefMutable(cd.get());
5414 if (cdm)
5415 {
5416 cdm->computeAnchors();
5417 }
5418 }
5419 for (const auto &fn : *Doxygen::inputNameLinkedMap)
5420 {
5421 for (const auto &fd : *fn)
5422 {
5423 fd->computeAnchors();
5424 }
5425 }
5426 for (const auto &nd : *Doxygen::namespaceLinkedMap)
5427 {
5429 if (ndm)
5430 {
5431 ndm->computeAnchors();
5432 }
5433 }
5434 for (const auto &gd : *Doxygen::groupLinkedMap)
5435 {
5436 gd->computeAnchors();
5437 }
5438}
5439
5440//----------------------------------------------------------------------
5441
5443{
5444 AUTO_TRACE();
5445 for (const auto &cd : *Doxygen::classLinkedMap)
5446 {
5447 ClassDefMutable *cdm = toClassDefMutable(cd.get());
5448 if (cdm)
5449 {
5450 cdm->addListReferences();
5451 }
5452 }
5453
5454 for (const auto &fn : *Doxygen::inputNameLinkedMap)
5455 {
5456 for (const auto &fd : *fn)
5457 {
5458 fd->addListReferences();
5459 }
5460 }
5461
5462 for (const auto &nd : *Doxygen::namespaceLinkedMap)
5463 {
5465 if (ndm)
5466 {
5467 ndm->addListReferences();
5468 }
5469 }
5470
5471 for (const auto &gd : *Doxygen::groupLinkedMap)
5472 {
5473 gd->addListReferences();
5474 }
5475
5476 for (const auto &pd : *Doxygen::pageLinkedMap)
5477 {
5478 QCString name = pd->getOutputFileBase();
5479 if (pd->getGroupDef())
5480 {
5481 name = pd->getGroupDef()->getOutputFileBase();
5482 }
5483 {
5484 const RefItemVector &xrefItems = pd->xrefListItems();
5485 addRefItem(xrefItems,
5486 name,
5487 theTranslator->trPage(TRUE,TRUE),
5488 name,pd->title(),QCString(),nullptr);
5489 }
5490 }
5491
5492 for (const auto &dd : *Doxygen::dirLinkedMap)
5493 {
5494 QCString name = dd->getOutputFileBase();
5495 //if (dd->getGroupDef())
5496 //{
5497 // name = dd->getGroupDef()->getOutputFileBase();
5498 //}
5499 const RefItemVector &xrefItems = dd->xrefListItems();
5500 addRefItem(xrefItems,
5501 name,
5502 theTranslator->trDir(TRUE,TRUE),
5503 name,dd->displayName(),QCString(),nullptr);
5504 }
5505
5507}
5508
5509//----------------------------------------------------------------------
5510
5512{
5513 AUTO_TRACE();
5515 {
5516 rl->generatePage();
5517 }
5518}
5519
5520//----------------------------------------------------------------------
5521// Copy the documentation in entry 'root' to member definition 'md' and
5522// set the function declaration of the member to 'funcDecl'. If the boolean
5523// over_load is set the standard overload text is added.
5524
5525static void addMemberDocs(const Entry *root,
5526 MemberDefMutable *md, const QCString &funcDecl,
5527 const ArgumentList *al,
5528 bool over_load,
5529 TypeSpecifier spec
5530 )
5531{
5532 if (md==nullptr) return;
5533 AUTO_TRACE("scope='{}' name='{}' args='{}' funcDecl='{}' mSpec={}",
5534 root->parent()->name,md->name(),md->argsString(),funcDecl,spec);
5535 if (!root->section.isDoc()) // @fn or @var does not need to specify the complete definition, so don't overwrite it
5536 {
5537 QCString fDecl=funcDecl;
5538 // strip extern specifier
5539 fDecl.stripPrefix("extern ");
5540 md->setDefinition(fDecl);
5541 }
5543 md->addQualifiers(root->qualifiers);
5545 const NamespaceDef *nd=md->getNamespaceDef();
5546 QCString fullName;
5547 if (cd)
5548 fullName = cd->name();
5549 else if (nd)
5550 fullName = nd->name();
5551
5552 if (!fullName.isEmpty()) fullName+="::";
5553 fullName+=md->name();
5554 FileDef *rfd=root->fileDef();
5555
5556 // TODO determine scope based on root not md
5557 Definition *rscope = md->getOuterScope();
5558
5559 const ArgumentList &mdAl = md->argumentList();
5560 if (al)
5561 {
5562 ArgumentList mergedAl = *al;
5563 //printf("merging arguments (1) docs=%d\n",root->doc.isEmpty());
5564 mergeArguments(const_cast<ArgumentList&>(mdAl),mergedAl,!root->doc.isEmpty());
5565 }
5566 else
5567 {
5568 if (
5569 matchArguments2( md->getOuterScope(), md->getFileDef(),const_cast<ArgumentList*>(&mdAl),
5570 rscope,rfd,&root->argList,
5571 TRUE, root->lang
5572 )
5573 )
5574 {
5575 //printf("merging arguments (2)\n");
5576 ArgumentList mergedArgList = root->argList;
5577 mergeArguments(const_cast<ArgumentList&>(mdAl),mergedArgList,!root->doc.isEmpty());
5578 }
5579 }
5580 if (over_load) // the \overload keyword was used
5581 {
5583 if (!root->doc.isEmpty())
5584 {
5585 doc+="<p>";
5586 doc+=root->doc;
5587 }
5588 md->setDocumentation(doc,root->docFile,root->docLine);
5590 md->setDocsForDefinition(!root->proto);
5591 }
5592 else
5593 {
5594 //printf("overwrite!\n");
5595 md->setDocumentation(root->doc,root->docFile,root->docLine);
5596 md->setDocsForDefinition(!root->proto);
5597
5598 //printf("overwrite!\n");
5599 md->setBriefDescription(root->brief,root->briefFile,root->briefLine);
5600
5601 if (
5602 (md->inbodyDocumentation().isEmpty() ||
5603 !root->parent()->name.isEmpty()
5604 ) && !root->inbodyDocs.isEmpty()
5605 )
5606 {
5608 }
5609 }
5610
5611 //printf("initializer: '%s'(isEmpty=%d) '%s'(isEmpty=%d)\n",
5612 // qPrint(md->initializer()),md->initializer().isEmpty(),
5613 // qPrint(root->initializer),root->initializer.isEmpty()
5614 // );
5615 std::string rootInit = root->initializer.str();
5616 if (md->initializer().isEmpty() && !rootInit.empty())
5617 {
5618 //printf("setInitializer\n");
5619 md->setInitializer(rootInit.c_str());
5620 }
5621 if (md->requiresClause().isEmpty() && !root->req.isEmpty())
5622 {
5623 md->setRequiresClause(root->req);
5624 }
5625
5626 md->setMaxInitLines(root->initLines);
5627
5628 if (rfd)
5629 {
5630 if ((md->getStartBodyLine()==-1 && root->bodyLine!=-1)
5631 )
5632 {
5633 //printf("Setting new body segment [%d,%d]\n",root->bodyLine,root->endBodyLine);
5634 md->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
5635 md->setBodyDef(rfd);
5636 }
5637
5638 md->setRefItems(root->sli);
5639 }
5640
5642 md->addQualifiers(root->qualifiers);
5643
5644 md->mergeMemberSpecifiers(spec);
5646 addMemberToGroups(root,md);
5648 if (cd) cd->insertUsedFile(rfd);
5649 //printf("root->mGrpId=%d\n",root->mGrpId);
5650 if (root->mGrpId!=-1)
5651 {
5652 if (md->getMemberGroupId()!=-1)
5653 {
5654 if (md->getMemberGroupId()!=root->mGrpId)
5655 {
5656 warn(root->fileName,root->startLine,
5657 "member {} belongs to two different groups. The second one found here will be ignored.",
5658 md->name()
5659 );
5660 }
5661 }
5662 else // set group id
5663 {
5664 //printf("setMemberGroupId=%d md=%s\n",root->mGrpId,qPrint(md->name()));
5665 md->setMemberGroupId(root->mGrpId);
5666 }
5667 }
5668 md->addQualifiers(root->qualifiers);
5669}
5670
5671//----------------------------------------------------------------------
5672// find a class definition given the scope name and (optionally) a
5673// template list specifier
5674
5676 const QCString &scopeName)
5677{
5678 SymbolResolver resolver(fd);
5679 const ClassDef *tcd = resolver.resolveClass(nd,scopeName,true,true);
5680 return tcd;
5681}
5682
5683//----------------------------------------------------------------------------
5684// Returns TRUE, if the entry belongs to the group of the member definition,
5685// otherwise FALSE.
5686
5687static bool isEntryInGroupOfMember(const Entry *root,const MemberDef *md,bool allowNoGroup=false)
5688{
5689 const GroupDef *gd = md->getGroupDef();
5690 if (!gd)
5691 {
5692 return allowNoGroup;
5693 }
5694
5695 for (const auto &g : root->groups)
5696 {
5697 if (g.groupname == gd->name())
5698 {
5699 return true; // matching group
5700 }
5701 }
5702
5703 return false;
5704}
5705
5706//----------------------------------------------------------------------
5707// Adds the documentation contained in 'root' to a global function
5708// with name 'name' and argument list 'args' (for overloading) and
5709// function declaration 'decl' to the corresponding member definition.
5710
5711static bool findGlobalMember(const Entry *root,
5712 const QCString &namespaceName,
5713 const QCString &type,
5714 const QCString &name,
5715 const QCString &tempArg,
5716 const QCString &,
5717 const QCString &decl,
5718 TypeSpecifier /* spec */)
5719{
5720 AUTO_TRACE("namespace='{}' type='{}' name='{}' tempArg='{}' decl='{}'",namespaceName,type,name,tempArg,decl);
5721 QCString n=name;
5722 if (n.isEmpty()) return FALSE;
5723 if (n.find("::")!=-1) return FALSE; // skip undefined class members
5724 MemberName *mn=Doxygen::functionNameLinkedMap->find(n+tempArg); // look in function dictionary
5725 if (mn==nullptr)
5726 {
5727 mn=Doxygen::functionNameLinkedMap->find(n); // try without template arguments
5728 }
5729 if (mn) // function name defined
5730 {
5731 AUTO_TRACE_ADD("Found symbol name");
5732 //int count=0;
5733 bool found=FALSE;
5734 for (const auto &md : *mn)
5735 {
5736 // If the entry has groups, then restrict the search to members which are
5737 // in one of the groups of the entry. If md is not associated with a group yet,
5738 // allow this documentation entry to add the group info.
5739 if (!root->groups.empty() && !isEntryInGroupOfMember(root, md.get(), true))
5740 {
5741 continue;
5742 }
5743
5744 const NamespaceDef *nd=nullptr;
5745 if (md->isAlias() && md->getOuterScope() &&
5746 md->getOuterScope()->definitionType()==Definition::TypeNamespace)
5747 {
5748 nd = toNamespaceDef(md->getOuterScope());
5749 }
5750 else
5751 {
5752 nd = md->getNamespaceDef();
5753 }
5754
5755 // special case for strong enums
5756 int enumNamePos=0;
5757 if (nd && md->isEnumValue() && (enumNamePos=namespaceName.findRev("::"))!=-1)
5758 { // md part of a strong enum in a namespace?
5759 QCString enumName = namespaceName.mid(enumNamePos+2);
5760 if (namespaceName.left(enumNamePos)==nd->name())
5761 {
5762 MemberName *enumMn=Doxygen::functionNameLinkedMap->find(enumName);
5763 if (enumMn)
5764 {
5765 for (const auto &emd : *enumMn)
5766 {
5767 found = emd->isStrong() && md->getEnumScope()==emd.get();
5768 if (found)
5769 {
5770 addMemberDocs(root,toMemberDefMutable(md->resolveAlias()),decl,nullptr,FALSE,root->spec);
5771 break;
5772 }
5773 }
5774 }
5775 }
5776 if (found)
5777 {
5778 break;
5779 }
5780 }
5781 else if (nd==nullptr && md->isEnumValue()) // md part of global strong enum?
5782 {
5783 MemberName *enumMn=Doxygen::functionNameLinkedMap->find(namespaceName);
5784 if (enumMn)
5785 {
5786 for (const auto &emd : *enumMn)
5787 {
5788 found = emd->isStrong() && md->getEnumScope()==emd.get();
5789 if (found)
5790 {
5791 addMemberDocs(root,toMemberDefMutable(md->resolveAlias()),decl,nullptr,FALSE,root->spec);
5792 break;
5793 }
5794 }
5795 }
5796 }
5797
5798 const FileDef *fd=root->fileDef();
5799 //printf("File %s\n",fd ? qPrint(fd->name()) : "<none>");
5801 if (fd)
5802 {
5803 nl = fd->getUsedNamespaces();
5804 }
5805 //printf("NamespaceList %p\n",nl);
5806
5807 // search in the list of namespaces that are imported via a
5808 // using declaration
5809 bool viaUsingDirective = nd && nl.find(nd->qualifiedName())!=nullptr;
5810
5811 if ((namespaceName.isEmpty() && nd==nullptr) || // not in a namespace
5812 (nd && nd->name()==namespaceName) || // or in the same namespace
5813 viaUsingDirective // member in 'using' namespace
5814 )
5815 {
5816 AUTO_TRACE_ADD("Try to add member '{}' to scope '{}'",md->name(),namespaceName);
5817
5818 NamespaceDef *rnd = nullptr;
5819 if (!namespaceName.isEmpty()) rnd = Doxygen::namespaceLinkedMap->find(namespaceName);
5820
5821 const ArgumentList &mdAl = md.get()->argumentList();
5822 bool matching=
5823 (mdAl.empty() && root->argList.empty()) ||
5824 md->isVariable() || md->isTypedef() || /* in case of function pointers */
5825 matchArguments2(md->getOuterScope(),md.get()->getFileDef(),&mdAl,
5826 rnd ? rnd : Doxygen::globalScope,fd,&root->argList,
5827 FALSE,root->lang);
5828
5829 // for template members we need to check if the number of
5830 // template arguments is the same, otherwise we are dealing with
5831 // different functions.
5832 if (matching && !root->tArgLists.empty())
5833 {
5834 const ArgumentList &mdTempl = md->templateArguments();
5835 if (root->tArgLists.back().size()!=mdTempl.size())
5836 {
5837 matching=FALSE;
5838 }
5839 }
5840
5841 //printf("%s<->%s\n",
5842 // qPrint(argListToString(md->argumentList())),
5843 // qPrint(argListToString(root->argList)));
5844
5845 // For static members we also check if the comment block was found in
5846 // the same file. This is needed because static members with the same
5847 // name can be in different files. Thus it would be wrong to just
5848 // put the comment block at the first syntactically matching member. If
5849 // the comment block belongs to a group of the static member, then add
5850 // the documentation even if it is in a different file.
5851 if (matching && md->isStatic() &&
5852 md->getDefFileName()!=root->fileName &&
5853 mn->size()>1 &&
5854 !isEntryInGroupOfMember(root,md.get()))
5855 {
5856 matching = FALSE;
5857 }
5858
5859 // for template member we also need to check the return type and requires
5860 if (!md->templateArguments().empty() && !root->tArgLists.empty())
5861 {
5862 //printf("Comparing return types '%s'<->'%s'\n",
5863 // md->typeString(),type);
5864 if (md->templateArguments().size()!=root->tArgLists.back().size() ||
5865 md->typeString()!=type ||
5866 md->requiresClause()!=root->req)
5867 {
5868 //printf(" ---> no matching\n");
5869 matching = FALSE;
5870 }
5871 }
5872
5873 if (matching) // add docs to the member
5874 {
5875 AUTO_TRACE_ADD("Match found");
5876 addMemberDocs(root,toMemberDefMutable(md->resolveAlias()),decl,&root->argList,FALSE,root->spec);
5877 found=TRUE;
5878 break;
5879 }
5880 }
5881 }
5882 if (!found && root->relatesType!=RelatesType::Duplicate && root->section.isFunction()) // no match
5883 {
5884 QCString fullFuncDecl=decl;
5885 if (!root->argList.empty()) fullFuncDecl+=argListToString(root->argList,TRUE);
5886 QCString warnMsg = "no matching file member found for \n"+fullFuncDecl;
5887 if (mn->size()>0)
5888 {
5889 warnMsg+="\nPossible candidates:";
5890 for (const auto &md : *mn)
5891 {
5892 warnMsg+="\n '";
5893 warnMsg+=replaceAnonymousScopes(md->declaration());
5894 warnMsg+="' " + warn_line(md->getDefFileName(),md->getDefLine());
5895 }
5896 }
5897 warn(root->fileName,root->startLine, "{}", qPrint(warnMsg));
5898 }
5899 }
5900 else // got docs for an undefined member!
5901 {
5902 if (root->type!="friend class" &&
5903 root->type!="friend struct" &&
5904 root->type!="friend union" &&
5905 root->type!="friend" &&
5906 (!Config_getBool(TYPEDEF_HIDES_STRUCT) ||
5907 root->type.find("typedef ")==-1)
5908 )
5909 {
5910 warn(root->fileName,root->startLine,
5911 "documented symbol '{}' was not declared or defined.",qPrint(decl)
5912 );
5913 }
5914 }
5915 return TRUE;
5916}
5917
5919 const ArgumentLists &srcTempArgLists,
5920 const ArgumentLists &dstTempArgLists
5921 )
5922{
5923 auto srcIt = srcTempArgLists.begin();
5924 auto dstIt = dstTempArgLists.begin();
5925 while (srcIt!=srcTempArgLists.end() && dstIt!=dstTempArgLists.end())
5926 {
5927 if ((*srcIt).size()!=(*dstIt).size()) return TRUE;
5928 ++srcIt;
5929 ++dstIt;
5930 }
5931 return FALSE;
5932}
5933
5934static bool scopeIsTemplate(const Definition *d)
5935{
5936 bool result=FALSE;
5937 //printf("> scopeIsTemplate(%s)\n",qPrint(d?d->name():"null"));
5939 {
5940 auto cd = toClassDef(d);
5941 result = cd->templateArguments().hasParameters() || cd->templateMaster()!=nullptr ||
5943 }
5944 //printf("< scopeIsTemplate=%d\n",result);
5945 return result;
5946}
5947
5949 const ArgumentLists &srcTempArgLists,
5950 const ArgumentLists &dstTempArgLists,
5951 const std::string &src
5952 )
5953{
5954 std::string dst;
5955 static const reg::Ex re(R"(\a\w*)");
5956 reg::Iterator it(src,re);
5958 //printf("type=%s\n",qPrint(sa->type));
5959 size_t p=0;
5960 for (; it!=end ; ++it) // for each word in srcType
5961 {
5962 const auto &match = *it;
5963 size_t i = match.position();
5964 size_t l = match.length();
5965 bool found=FALSE;
5966 dst+=src.substr(p,i-p);
5967 std::string name=match.str();
5968
5969 auto srcIt = srcTempArgLists.begin();
5970 auto dstIt = dstTempArgLists.begin();
5971 while (srcIt!=srcTempArgLists.end() && !found)
5972 {
5973 const ArgumentList *tdAli = nullptr;
5974 std::vector<Argument>::const_iterator tdaIt;
5975 if (dstIt!=dstTempArgLists.end())
5976 {
5977 tdAli = &(*dstIt);
5978 tdaIt = tdAli->begin();
5979 ++dstIt;
5980 }
5981
5982 const ArgumentList &tsaLi = *srcIt;
5983 for (auto tsaIt = tsaLi.begin(); tsaIt!=tsaLi.end() && !found; ++tsaIt)
5984 {
5985 Argument tsa = *tsaIt;
5986 const Argument *tda = nullptr;
5987 if (tdAli && tdaIt!=tdAli->end())
5988 {
5989 tda = &(*tdaIt);
5990 ++tdaIt;
5991 }
5992 //if (tda) printf("tsa=%s|%s tda=%s|%s\n",
5993 // qPrint(tsa.type),qPrint(tsa.name),
5994 // qPrint(tda->type),qPrint(tda->name));
5995 if (name==tsa.name.str())
5996 {
5997 if (tda && tda->name.isEmpty())
5998 {
5999 QCString tdaName = tda->name;
6000 QCString tdaType = tda->type;
6001 int vc=0;
6002 if (tdaType.startsWith("class ")) vc=6;
6003 else if (tdaType.startsWith("typename ")) vc=9;
6004 if (vc>0) // convert type=="class T" to type=="class" name=="T"
6005 {
6006 tdaName = tdaType.mid(vc);
6007 }
6008 if (!tdaName.isEmpty())
6009 {
6010 name=tdaName.str(); // substitute
6011 found=TRUE;
6012 }
6013 }
6014 }
6015 }
6016
6017 //printf(" srcList='%s' dstList='%s faList='%s'\n",
6018 // qPrint(argListToString(srclali.current())),
6019 // qPrint(argListToString(dstlali.current())),
6020 // funcTempArgList ? qPrint(argListToString(funcTempArgList)) : "<none>");
6021 ++srcIt;
6022 }
6023 dst+=name;
6024 p=i+l;
6025 }
6026 dst+=src.substr(p);
6027 //printf(" substituteTemplatesInString(%s)=%s\n",
6028 // qPrint(src),qPrint(dst));
6029 return QCString(dst);
6030}
6031
6033 const ArgumentLists &srcTempArgLists,
6034 const ArgumentLists &dstTempArgLists,
6035 const ArgumentList &src,
6036 ArgumentList &dst
6037 )
6038{
6039 auto dstIt = dst.begin();
6040 for (const Argument &sa : src)
6041 {
6042 QCString dstType = substituteTemplatesInString(srcTempArgLists,dstTempArgLists,sa.type.str());
6043 QCString dstArray = substituteTemplatesInString(srcTempArgLists,dstTempArgLists,sa.array.str());
6044 if (dstIt == dst.end())
6045 {
6046 Argument da = sa;
6047 da.type = dstType;
6048 da.array = dstArray;
6049 dst.push_back(da);
6050 dstIt = dst.end();
6051 }
6052 else
6053 {
6054 Argument da = *dstIt;
6055 da.type = dstType;
6056 da.array = dstArray;
6057 ++dstIt;
6058 }
6059 }
6064 srcTempArgLists,dstTempArgLists,
6065 src.trailingReturnType().str()));
6066 dst.setIsDeleted(src.isDeleted());
6067 dst.setRefQualifier(src.refQualifier());
6068 dst.setNoParameters(src.noParameters());
6069 //printf("substituteTemplatesInArgList: replacing %s with %s\n",
6070 // qPrint(argListToString(src)),qPrint(argListToString(dst))
6071 // );
6072}
6073
6074//-------------------------------------------------------------------------------------------
6075
6076static void addLocalObjCMethod(const Entry *root,
6077 const QCString &scopeName,
6078 const QCString &funcType,const QCString &funcName,const QCString &funcArgs,
6079 const QCString &exceptions,const QCString &funcDecl,
6080 TypeSpecifier spec)
6081{
6082 AUTO_TRACE();
6083 //printf("scopeName='%s' className='%s'\n",qPrint(scopeName),qPrint(className));
6084 ClassDefMutable *cd=nullptr;
6085 if (Config_getBool(EXTRACT_LOCAL_METHODS) && (cd=getClassMutable(scopeName)))
6086 {
6087 AUTO_TRACE_ADD("Local objective C method '{}' scopeName='{}'",root->name,scopeName);
6088 auto md = createMemberDef(
6089 root->fileName,root->startLine,root->startColumn,
6090 funcType,funcName,funcArgs,exceptions,
6091 root->protection,root->virt,root->isStatic,Relationship::Member,
6093 auto mmd = toMemberDefMutable(md.get());
6094 mmd->setTagInfo(root->tagInfo());
6095 mmd->setLanguage(root->lang);
6096 mmd->setId(root->id);
6097 mmd->makeImplementationDetail();
6098 mmd->setMemberClass(cd);
6099 mmd->setDefinition(funcDecl);
6101 mmd->addQualifiers(root->qualifiers);
6102 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
6103 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
6104 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
6105 mmd->setDocsForDefinition(!root->proto);
6106 mmd->setPrototype(root->proto,root->fileName,root->startLine,root->startColumn);
6107 mmd->addSectionsToDefinition(root->anchors);
6108 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
6109 FileDef *fd=root->fileDef();
6110 mmd->setBodyDef(fd);
6111 mmd->setMemberSpecifiers(spec);
6112 mmd->setVhdlSpecifiers(root->vhdlSpec);
6113 mmd->setMemberGroupId(root->mGrpId);
6114 cd->insertMember(md.get());
6115 cd->insertUsedFile(fd);
6116 mmd->setRefItems(root->sli);
6117
6119 mn->push_back(std::move(md));
6120 }
6121 else
6122 {
6123 // local objective C method found for class without interface
6124 }
6125}
6126
6127//-------------------------------------------------------------------------------------------
6128
6129static void addMemberFunction(const Entry *root,
6130 MemberName *mn,
6131 const QCString &scopeName,
6132 const QCString &namespaceName,
6133 const QCString &className,
6134 const QCString &funcTyp,
6135 const QCString &funcName,
6136 const QCString &funcArgs,
6137 const QCString &funcTempList,
6138 const QCString &exceptions,
6139 const QCString &type,
6140 const QCString &args,
6141 bool isFriend,
6142 TypeSpecifier spec,
6143 const QCString &relates,
6144 const QCString &funcDecl,
6145 bool overloaded,
6146 bool isFunc)
6147{
6148 AUTO_TRACE();
6149 QCString funcType = funcTyp;
6150 int count=0;
6151 int noMatchCount=0;
6152 bool memFound=FALSE;
6153 for (const auto &imd : *mn)
6154 {
6155 MemberDefMutable *md = toMemberDefMutable(imd.get());
6156 if (md==nullptr) continue;
6158 if (cd==nullptr) continue;
6159 //AUTO_TRACE_ADD("member definition found, scope needed='{}' scope='{}' args='{}' fileName='{}'",
6160 // scopeName, cd->name(), md->argsString(), root->fileName);
6161 FileDef *fd=root->fileDef();
6162 NamespaceDef *nd=nullptr;
6163 if (!namespaceName.isEmpty()) nd=getResolvedNamespace(namespaceName);
6164
6165 //printf("scopeName %s->%s\n",qPrint(scopeName),
6166 // qPrint(stripTemplateSpecifiersFromScope(scopeName,FALSE)));
6167
6168 // if the member we are searching for is an enum value that is part of
6169 // a "strong" enum, we need to look into the fields of the enum for a match
6170 int enumNamePos=0;
6171 if (md->isEnumValue() && (enumNamePos=className.findRev("::"))!=-1)
6172 {
6173 QCString enumName = className.mid(enumNamePos+2);
6174 QCString fullScope = className.left(enumNamePos);
6175 if (!namespaceName.isEmpty()) fullScope.prepend(namespaceName+"::");
6176 if (fullScope==cd->name())
6177 {
6178 MemberName *enumMn=Doxygen::memberNameLinkedMap->find(enumName);
6179 //printf("enumMn(%s)=%p\n",qPrint(className),(void*)enumMn);
6180 if (enumMn)
6181 {
6182 for (const auto &emd : *enumMn)
6183 {
6184 memFound = emd->isStrong() && md->getEnumScope()==emd.get();
6185 if (memFound)
6186 {
6187 addMemberDocs(root,md,funcDecl,nullptr,overloaded,spec);
6188 count++;
6189 }
6190 if (memFound) break;
6191 }
6192 }
6193 }
6194 }
6195 if (memFound) break;
6196
6197 const ClassDef *tcd=findClassDefinition(fd,nd,scopeName);
6198 if (tcd==nullptr && cd && stripAnonymousNamespaceScope(cd->name())==scopeName)
6199 {
6200 // don't be fooled by anonymous scopes
6201 tcd=cd;
6202 }
6203 //printf("Looking for %s inside nd=%s result=%p (%s) cd=%p\n",
6204 // qPrint(scopeName),nd?qPrint(nd->name()):"<none>",tcd,tcd?qPrint(tcd->name()):"",cd);
6205
6206 if (cd && tcd==cd) // member's classes match
6207 {
6208 AUTO_TRACE_ADD("class definition '{}' found",cd->name());
6209
6210 // get the template parameter lists found at the member declaration
6211 ArgumentLists declTemplArgs = cd->getTemplateParameterLists();
6212 const ArgumentList &templAl = md->templateArguments();
6213 if (!templAl.empty())
6214 {
6215 declTemplArgs.push_back(templAl);
6216 }
6217
6218 // get the template parameter lists found at the member definition
6219 const ArgumentLists &defTemplArgs = root->tArgLists;
6220 //printf("defTemplArgs=%p\n",defTemplArgs);
6221
6222 // do we replace the decl argument lists with the def argument lists?
6223 bool substDone=FALSE;
6224 ArgumentList argList;
6225
6226 /* substitute the occurrences of class template names in the
6227 * argument list before matching
6228 */
6229 const ArgumentList &mdAl = md->argumentList();
6230 if (declTemplArgs.size()>0 && declTemplArgs.size()==defTemplArgs.size())
6231 {
6232 /* the function definition has template arguments
6233 * and the class definition also has template arguments, so
6234 * we must substitute the template names of the class by that
6235 * of the function definition before matching.
6236 */
6237 substituteTemplatesInArgList(declTemplArgs,defTemplArgs,mdAl,argList);
6238
6239 substDone=TRUE;
6240 }
6241 else /* no template arguments, compare argument lists directly */
6242 {
6243 argList = mdAl;
6244 }
6245
6246 AUTO_TRACE_ADD("matching '{}'<=>'{}' className='{}' namespaceName='{}'",
6247 argListToString(argList,TRUE),argListToString(root->argList,TRUE),className,namespaceName);
6248
6249 bool matching=
6250 md->isVariable() || md->isTypedef() || // needed for function pointers
6252 md->getClassDef(),md->getFileDef(),&argList,
6253 cd,fd,&root->argList,
6254 TRUE,root->lang);
6255
6256 if (md->getLanguage()==SrcLangExt::ObjC && md->isVariable() && root->section.isFunction())
6257 {
6258 matching = FALSE; // don't match methods and attributes with the same name
6259 }
6260
6261 // for template member we also need to check the return type
6262 if (!md->templateArguments().empty() && !root->tArgLists.empty())
6263 {
6264 QCString memType = md->typeString();
6265 memType.stripPrefix("static "); // see bug700696
6267 className+"::",""); // see bug700693 & bug732594
6269 className+"::",""); // see bug758900
6270 AUTO_TRACE_ADD("Comparing return types '{}'<->'{}' #args {}<->{}",
6271 md->typeString(),funcType,md->templateArguments().size(),root->tArgLists.back().size());
6272 if (md->templateArguments().size()!=root->tArgLists.back().size() || memType!=funcType)
6273 {
6274 //printf(" ---> no matching\n");
6275 matching = FALSE;
6276 }
6277 }
6278 else if (defTemplArgs.size()>declTemplArgs.size())
6279 {
6280 AUTO_TRACE_ADD("Different number of template arguments {} vs {}",defTemplArgs.size(),declTemplArgs.size());
6281 // avoid matching a non-template function in a template class against a
6282 // template function with the same name and parameters, see issue #10184
6283 substDone = false;
6284 matching = false;
6285 }
6286 bool rootIsUserDoc = root->section.isMemberDoc();
6287 bool classIsTemplate = scopeIsTemplate(md->getClassDef());
6288 bool mdIsTemplate = md->templateArguments().hasParameters();
6289 bool classOrMdIsTemplate = mdIsTemplate || classIsTemplate;
6290 bool rootIsTemplate = !root->tArgLists.empty();
6291 //printf("classIsTemplate=%d mdIsTemplate=%d rootIsTemplate=%d\n",classIsTemplate,mdIsTemplate,rootIsTemplate);
6292 if (!rootIsUserDoc && // don't check out-of-line @fn references, see bug722457
6293 (mdIsTemplate || rootIsTemplate) && // either md or root is a template
6294 ((classOrMdIsTemplate && !rootIsTemplate) || (!classOrMdIsTemplate && rootIsTemplate))
6295 )
6296 {
6297 // Method with template return type does not match method without return type
6298 // even if the parameters are the same. See also bug709052
6299 AUTO_TRACE_ADD("Comparing return types: template v.s. non-template");
6300 matching = FALSE;
6301 }
6302
6303 AUTO_TRACE_ADD("Match results of matchArguments2='{}' substDone='{}'",matching,substDone);
6304
6305 if (substDone) // found a new argument list
6306 {
6307 if (matching) // replace member's argument list
6308 {
6310 md->moveArgumentList(std::make_unique<ArgumentList>(argList));
6311 }
6312 else // no match
6313 {
6314 if (!funcTempList.isEmpty() &&
6315 isSpecialization(declTemplArgs,defTemplArgs))
6316 {
6317 // check if we are dealing with a partial template
6318 // specialization. In this case we add it to the class
6319 // even though the member arguments do not match.
6320
6321 addMethodToClass(root,cd,type,md->name(),args,isFriend,
6322 md->protection(),md->isStatic(),md->virtualness(),spec,relates);
6323 return;
6324 }
6325 }
6326 }
6327 if (matching)
6328 {
6329 addMemberDocs(root,md,funcDecl,nullptr,overloaded,spec);
6330 count++;
6331 memFound=TRUE;
6332 }
6333 }
6334 else if (cd && cd!=tcd) // we did find a class with the same name as cd
6335 // but in a different namespace
6336 {
6337 noMatchCount++;
6338 }
6339
6340 if (memFound) break;
6341 }
6342 if (count==0 && root->parent() && root->parent()->section.isObjcImpl())
6343 {
6344 addLocalObjCMethod(root,scopeName,funcType,funcName,funcArgs,exceptions,funcDecl,spec);
6345 return;
6346 }
6347 if (count==0 && !(isFriend && funcType=="class"))
6348 {
6349 int candidates=0;
6350 const ClassDef *ecd = nullptr, *ucd = nullptr;
6351 MemberDef *emd = nullptr, *umd = nullptr;
6352 //printf("Assume template class\n");
6353 for (const auto &md : *mn)
6354 {
6355 MemberDef *cmd=md.get();
6357 ClassDefMutable *ccd=cdmdm ? cdmdm->getClassDefMutable() : nullptr;
6358 //printf("ccd->name()==%s className=%s\n",qPrint(ccd->name()),qPrint(className));
6359 if (ccd!=nullptr && rightScopeMatch(ccd->name(),className))
6360 {
6361 const ArgumentList &templAl = md->templateArguments();
6362 if (!root->tArgLists.empty() && !templAl.empty() &&
6363 root->tArgLists.back().size()<=templAl.size())
6364 {
6365 AUTO_TRACE_ADD("add template specialization");
6366 addMethodToClass(root,ccd,type,md->name(),args,isFriend,
6367 root->protection,root->isStatic,root->virt,spec,relates);
6368 return;
6369 }
6370 if (argListToString(md->argumentList(),FALSE,FALSE) ==
6372 { // exact argument list match -> remember
6373 ucd = ecd = ccd;
6374 umd = emd = cmd;
6375 AUTO_TRACE_ADD("new candidate className='{}' scope='{}' args='{}': exact match",
6376 className,ccd->name(),md->argsString());
6377 }
6378 else // arguments do not match, but member name and scope do -> remember
6379 {
6380 ucd = ccd;
6381 umd = cmd;
6382 AUTO_TRACE_ADD("new candidate className='{}' scope='{}' args='{}': no match",
6383 className,ccd->name(),md->argsString());
6384 }
6385 candidates++;
6386 }
6387 }
6388 bool strictProtoMatching = Config_getBool(STRICT_PROTO_MATCHING);
6389 if (!strictProtoMatching)
6390 {
6391 if (candidates==1 && ucd && umd)
6392 {
6393 // we didn't find an actual match on argument lists, but there is only 1 member with this
6394 // name in the same scope, so that has to be the one.
6395 addMemberDocs(root,toMemberDefMutable(umd),funcDecl,nullptr,overloaded,spec);
6396 return;
6397 }
6398 else if (candidates>1 && ecd && emd)
6399 {
6400 // we didn't find a unique match using type resolution,
6401 // but one of the matches has the exact same signature so
6402 // we take that one.
6403 addMemberDocs(root,toMemberDefMutable(emd),funcDecl,nullptr,overloaded,spec);
6404 return;
6405 }
6406 }
6407
6408 QCString warnMsg = "no ";
6409 if (noMatchCount>1) warnMsg+="uniquely ";
6410 warnMsg+="matching class member found for \n";
6411
6412 for (const ArgumentList &al : root->tArgLists)
6413 {
6414 warnMsg+=" template ";
6415 warnMsg+=tempArgListToString(al,root->lang);
6416 warnMsg+='\n';
6417 }
6418
6419 QCString fullFuncDecl=funcDecl;
6420 if (isFunc) fullFuncDecl+=argListToString(root->argList,TRUE);
6421
6422 warnMsg+=" ";
6423 warnMsg+=fullFuncDecl;
6424
6425 if (candidates>0 || noMatchCount>=1)
6426 {
6427 warnMsg+="\nPossible candidates:";
6428
6429 NamespaceDef *nd=nullptr;
6430 if (!namespaceName.isEmpty()) nd=getResolvedNamespace(namespaceName);
6431 FileDef *fd=root->fileDef();
6432
6433 for (const auto &md : *mn)
6434 {
6435 const ClassDef *cd=md->getClassDef();
6436 const ClassDef *tcd=findClassDefinition(fd,nd,scopeName);
6437 if (tcd==nullptr && cd && stripAnonymousNamespaceScope(cd->name())==scopeName)
6438 {
6439 // don't be fooled by anonymous scopes
6440 tcd=cd;
6441 }
6442 if (cd!=nullptr && (rightScopeMatch(cd->name(),className) || (cd!=tcd)))
6443 {
6444 warnMsg+='\n';
6445 const ArgumentList &templAl = md->templateArguments();
6446 warnMsg+=" '";
6447 if (templAl.hasParameters())
6448 {
6449 warnMsg+="template ";
6450 warnMsg+=tempArgListToString(templAl,root->lang);
6451 warnMsg+='\n';
6452 warnMsg+=" ";
6453 }
6454 if (!md->typeString().isEmpty())
6455 {
6456 warnMsg+=md->typeString();
6457 warnMsg+=' ';
6458 }
6460 if (!qScope.isEmpty())
6461 warnMsg+=qScope+"::"+md->name();
6462 warnMsg+=md->argsString();
6463 warnMsg+="' " + warn_line(md->getDefFileName(),md->getDefLine());
6464 }
6465 }
6466 }
6467 warn(root->fileName,root->startLine,"{}",warnMsg);
6468 }
6469}
6470
6471//-------------------------------------------------------------------------------------------
6472
6473static void addMemberSpecialization(const Entry *root,
6474 MemberName *mn,
6475 ClassDefMutable *cd,
6476 const QCString &funcType,
6477 const QCString &funcName,
6478 const QCString &funcArgs,
6479 const QCString &funcDecl,
6480 const QCString &exceptions,
6481 TypeSpecifier spec
6482 )
6483{
6484 AUTO_TRACE("funcType={} funcName={} funcArgs={} funcDecl={} spec={}",funcType,funcName,funcArgs,funcDecl,spec);
6485 MemberDef *declMd=nullptr;
6486 for (const auto &md : *mn)
6487 {
6488 if (md->getClassDef()==cd)
6489 {
6490 // TODO: we should probably also check for matching arguments
6491 declMd = md.get();
6492 break;
6493 }
6494 }
6496 ArgumentList tArgList;
6497 // getTemplateArgumentsFromName(cd->name()+"::"+funcName,root->tArgLists);
6498 auto md = createMemberDef(
6499 root->fileName,root->startLine,root->startColumn,
6500 funcType,funcName,funcArgs,exceptions,
6501 declMd ? declMd->protection() : root->protection,
6502 root->virt,root->isStatic,Relationship::Member,
6503 mtype,tArgList,root->argList,root->metaData);
6504 auto mmd = toMemberDefMutable(md.get());
6505 //printf("new specialized member %s args='%s'\n",qPrint(md->name()),qPrint(funcArgs));
6506 mmd->setTagInfo(root->tagInfo());
6507 mmd->setLanguage(root->lang);
6508 mmd->setId(root->id);
6509 mmd->setMemberClass(cd);
6510 mmd->setTemplateSpecialization(TRUE);
6511 mmd->setTypeConstraints(root->typeConstr);
6512 mmd->setDefinition(funcDecl);
6514 mmd->addQualifiers(root->qualifiers);
6515 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
6516 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
6517 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
6518 mmd->setDocsForDefinition(!root->proto);
6519 mmd->setPrototype(root->proto,root->fileName,root->startLine,root->startColumn);
6520 mmd->addSectionsToDefinition(root->anchors);
6521 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
6522 FileDef *fd=root->fileDef();
6523 mmd->setBodyDef(fd);
6524 mmd->setMemberSpecifiers(spec);
6525 mmd->setVhdlSpecifiers(root->vhdlSpec);
6526 mmd->setMemberGroupId(root->mGrpId);
6527 cd->insertMember(md.get());
6528 mmd->setRefItems(root->sli);
6529
6530 mn->push_back(std::move(md));
6531}
6532
6533//-------------------------------------------------------------------------------------------
6534
6535static void addOverloaded(const Entry *root,MemberName *mn,
6536 const QCString &funcType,const QCString &funcName,const QCString &funcArgs,
6537 const QCString &funcDecl,const QCString &exceptions,TypeSpecifier spec)
6538{
6539 // for unique overloaded member we allow the class to be
6540 // omitted, this is to be Qt compatible. Using this should
6541 // however be avoided, because it is error prone
6542 bool sameClass=false;
6543 if (mn->size()>0)
6544 {
6545 // check if all members with the same name are also in the same class
6546 sameClass = std::equal(mn->begin()+1,mn->end(),mn->begin(),
6547 [](const auto &md1,const auto &md2)
6548 { return md1->getClassDef()->name()==md2->getClassDef()->name(); });
6549 }
6550 if (sameClass)
6551 {
6552 MemberDefMutable *mdm = toMemberDefMutable(mn->front().get());
6553 ClassDefMutable *cd = mdm ? mdm->getClassDefMutable() : nullptr;
6554 if (cd==nullptr) return;
6555
6557 if (root->mtype==MethodTypes::Signal) mtype=MemberType::Signal;
6558 else if (root->mtype==MethodTypes::Slot) mtype=MemberType::Slot;
6559 else if (root->mtype==MethodTypes::DCOP) mtype=MemberType::DCOP;
6560
6561 // new overloaded member function
6562 std::unique_ptr<ArgumentList> tArgList =
6563 getTemplateArgumentsFromName(cd->name()+"::"+funcName,root->tArgLists);
6564 //printf("new related member %s args='%s'\n",qPrint(md->name()),qPrint(funcArgs));
6565 auto md = createMemberDef(
6566 root->fileName,root->startLine,root->startColumn,
6567 funcType,funcName,funcArgs,exceptions,
6568 root->protection,root->virt,root->isStatic,Relationship::Related,
6569 mtype,tArgList ? *tArgList : ArgumentList(),root->argList,root->metaData);
6570 auto mmd = toMemberDefMutable(md.get());
6571 mmd->setTagInfo(root->tagInfo());
6572 mmd->setLanguage(root->lang);
6573 mmd->setId(root->id);
6574 mmd->setTypeConstraints(root->typeConstr);
6575 mmd->setMemberClass(cd);
6576 mmd->setDefinition(funcDecl);
6578 mmd->addQualifiers(root->qualifiers);
6580 doc+="<p>";
6581 doc+=root->doc;
6582 mmd->setDocumentation(doc,root->docFile,root->docLine);
6583 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
6584 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
6585 mmd->setDocsForDefinition(!root->proto);
6586 mmd->setPrototype(root->proto,root->fileName,root->startLine,root->startColumn);
6587 mmd->addSectionsToDefinition(root->anchors);
6588 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
6589 FileDef *fd=root->fileDef();
6590 mmd->setBodyDef(fd);
6591 mmd->setMemberSpecifiers(spec);
6592 mmd->setVhdlSpecifiers(root->vhdlSpec);
6593 mmd->setMemberGroupId(root->mGrpId);
6594 cd->insertMember(md.get());
6595 cd->insertUsedFile(fd);
6596 mmd->setRefItems(root->sli);
6597
6598 mn->push_back(std::move(md));
6599 }
6600}
6601
6602static void insertMemberAlias(Definition *outerScope,const MemberDef *md)
6603{
6604 if (outerScope && outerScope!=Doxygen::globalScope)
6605 {
6606 auto aliasMd = createMemberDefAlias(outerScope,md);
6607 if (outerScope->definitionType()==Definition::TypeClass)
6608 {
6609 ClassDefMutable *cdm = toClassDefMutable(outerScope);
6610 if (cdm)
6611 {
6612 cdm->insertMember(aliasMd.get());
6613 }
6614 }
6615 else if (outerScope->definitionType()==Definition::TypeNamespace)
6616 {
6617 NamespaceDefMutable *ndm = toNamespaceDefMutable(outerScope);
6618 if (ndm)
6619 {
6620 ndm->insertMember(aliasMd.get());
6621 }
6622 }
6623 else if (outerScope->definitionType()==Definition::TypeFile)
6624 {
6625 toFileDef(outerScope)->insertMember(aliasMd.get());
6626 }
6627 if (aliasMd)
6628 {
6629 Doxygen::functionNameLinkedMap->add(md->name())->push_back(std::move(aliasMd));
6630 }
6631 }
6632}
6633
6634//-------------------------------------------------------------------------------------------
6635
6636/*! This function tries to find a member (in a documented class/file/namespace)
6637 * that corresponds to the function/variable declaration given in \a funcDecl.
6638 *
6639 * The boolean \a overloaded is used to specify whether or not a standard
6640 * overload documentation line should be generated.
6641 *
6642 * The boolean \a isFunc is a hint that indicates that this is a function
6643 * instead of a variable or typedef.
6644 */
6645static void findMember(const Entry *root,
6646 const QCString &relates,
6647 const QCString &type,
6648 const QCString &args,
6649 QCString funcDecl,
6650 bool overloaded,
6651 bool isFunc
6652 )
6653{
6654 AUTO_TRACE("root='{}' funcDecl='{}' related='{}' overload={} isFunc={} mGrpId={} #tArgList={} spec={} lang={}",
6655 root->name, funcDecl, relates, overloaded, isFunc, root->mGrpId, root->tArgLists.size(),
6656 root->spec, root->lang);
6657
6658 QCString scopeName;
6659 QCString className;
6660 QCString namespaceName;
6661 QCString funcType;
6662 QCString funcName;
6663 QCString funcArgs;
6664 QCString funcTempList;
6665 QCString exceptions;
6666 QCString funcSpec;
6667 bool isRelated=false;
6668 bool isMemberOf=false;
6669 bool isFriend=false;
6670 bool done=false;
6671 TypeSpecifier spec = root->spec;
6672 while (!done)
6673 {
6674 done=true;
6675 if (funcDecl.stripPrefix("friend ")) // treat friends as related members
6676 {
6677 isFriend=true;
6678 done=false;
6679 }
6680 if (funcDecl.stripPrefix("inline "))
6681 {
6682 spec.setInline(true);
6683 done=false;
6684 }
6685 if (funcDecl.stripPrefix("explicit "))
6686 {
6687 spec.setExplicit(true);
6688 done=false;
6689 }
6690 if (funcDecl.stripPrefix("mutable "))
6691 {
6692 spec.setMutable(true);
6693 done=false;
6694 }
6695 if (funcDecl.stripPrefix("virtual "))
6696 {
6697 done=false;
6698 }
6699 }
6700
6701 // delete any ; from the function declaration
6702 int sep=0;
6703 while ((sep=funcDecl.find(';'))!=-1)
6704 {
6705 funcDecl=(funcDecl.left(sep)+funcDecl.right(funcDecl.length()-sep-1)).stripWhiteSpace();
6706 }
6707
6708 // make sure the first character is a space to simplify searching.
6709 if (!funcDecl.isEmpty() && funcDecl[0]!=' ') funcDecl.prepend(" ");
6710
6711 // remove some superfluous spaces
6712 funcDecl= substitute(
6713 substitute(
6714 substitute(funcDecl,"~ ","~"),
6715 ":: ","::"
6716 ),
6717 " ::","::"
6718 ).stripWhiteSpace();
6719
6720 //printf("funcDecl='%s'\n",qPrint(funcDecl));
6721 if (isFriend && funcDecl.startsWith("class "))
6722 {
6723 //printf("friend class\n");
6724 funcDecl=funcDecl.right(funcDecl.length()-6);
6725 funcName = funcDecl;
6726 }
6727 else if (isFriend && funcDecl.startsWith("struct "))
6728 {
6729 funcDecl=funcDecl.right(funcDecl.length()-7);
6730 funcName = funcDecl;
6731 }
6732 else
6733 {
6734 // extract information from the declarations
6735 parseFuncDecl(funcDecl,root->lang,scopeName,funcType,funcName,
6736 funcArgs,funcTempList,exceptions
6737 );
6738 }
6739
6740 // the class name can also be a namespace name, we decide this later.
6741 // if a related class name is specified and the class name could
6742 // not be derived from the function declaration, then use the
6743 // related field.
6744 AUTO_TRACE_ADD("scopeName='{}' className='{}' namespaceName='{}' funcType='{}' funcName='{}' funcArgs='{}'",
6745 scopeName,className,namespaceName,funcType,funcName,funcArgs);
6746 if (!relates.isEmpty())
6747 { // related member, prefix user specified scope
6748 isRelated=TRUE;
6749 isMemberOf=(root->relatesType == RelatesType::MemberOf);
6750 if (getClass(relates)==nullptr && !scopeName.isEmpty())
6751 {
6752 scopeName= mergeScopes(scopeName,relates);
6753 }
6754 else
6755 {
6756 scopeName = relates;
6757 }
6758 }
6759
6760 if (relates.isEmpty() && root->parent() &&
6761 (root->parent()->section.isScope() || root->parent()->section.isObjcImpl()) &&
6762 !root->parent()->name.isEmpty()) // see if we can combine scopeName
6763 // with the scope in which it was found
6764 {
6765 QCString joinedName = root->parent()->name+"::"+scopeName;
6766 if (!scopeName.isEmpty() &&
6767 (getClass(joinedName) || Doxygen::namespaceLinkedMap->find(joinedName)))
6768 {
6769 scopeName = joinedName;
6770 }
6771 else
6772 {
6773 scopeName = mergeScopes(root->parent()->name,scopeName);
6774 }
6775 }
6776 else // see if we can prefix a namespace or class that is used from the file
6777 {
6778 FileDef *fd=root->fileDef();
6779 if (fd)
6780 {
6781 for (const auto &fnd : fd->getUsedNamespaces())
6782 {
6783 QCString joinedName = fnd->name()+"::"+scopeName;
6784 if (Doxygen::namespaceLinkedMap->find(joinedName))
6785 {
6786 scopeName=joinedName;
6787 break;
6788 }
6789 }
6790 }
6791 }
6793 removeRedundantWhiteSpace(scopeName),false,&funcSpec,QCString(),false);
6794
6795 // funcSpec contains the last template specifiers of the given scope.
6796 // If this method does not have any template arguments or they are
6797 // empty while funcSpec is not empty we assume this is a
6798 // specialization of a method. If not, we clear the funcSpec and treat
6799 // this as a normal method of a template class.
6800 if (!(root->tArgLists.size()>0 &&
6801 root->tArgLists.front().size()==0
6802 )
6803 )
6804 {
6805 funcSpec.clear();
6806 }
6807
6808 //namespaceName=removeAnonymousScopes(namespaceName);
6809 if (!Config_getBool(EXTRACT_ANON_NSPACES) && scopeName.find('@')!=-1) return; // skip stuff in anonymous namespace...
6810
6811 // split scope into a namespace and a class part
6812 extractNamespaceName(scopeName,className,namespaceName,TRUE);
6813 AUTO_TRACE_ADD("scopeName='{}' className='{}' namespaceName='{}'",scopeName,className,namespaceName);
6814
6815 //printf("namespaceName='%s' className='%s'\n",qPrint(namespaceName),qPrint(className));
6816 // merge class and namespace scopes again
6817 scopeName.clear();
6818 if (!namespaceName.isEmpty())
6819 {
6820 if (className.isEmpty())
6821 {
6822 scopeName=namespaceName;
6823 }
6824 else if (!relates.isEmpty() || // relates command with explicit scope
6825 !getClass(className)) // class name only exists in a namespace
6826 {
6827 scopeName=namespaceName+"::"+className;
6828 }
6829 else
6830 {
6831 scopeName=className;
6832 }
6833 }
6834 else if (!className.isEmpty())
6835 {
6836 scopeName=className;
6837 }
6838 //printf("new scope='%s'\n",qPrint(scopeName));
6839
6840 QCString tempScopeName=scopeName;
6841 ClassDefMutable *cd=getClassMutable(scopeName);
6842 if (cd)
6843 {
6844 if (funcSpec.isEmpty())
6845 {
6846 uint32_t argListIndex=0;
6847 tempScopeName=cd->qualifiedNameWithTemplateParameters(&root->tArgLists,&argListIndex);
6848 }
6849 else
6850 {
6851 tempScopeName=scopeName+funcSpec;
6852 }
6853 }
6854 //printf("scopeName=%s cd=%p root->tArgLists=%p result=%s\n",
6855 // qPrint(scopeName),cd,root->tArgLists,qPrint(tempScopeName));
6856
6857 //printf("scopeName='%s' className='%s'\n",qPrint(scopeName),qPrint(className));
6858 // rebuild the function declaration (needed to get the scope right).
6859 if (!scopeName.isEmpty() && !isRelated && !isFriend && !Config_getBool(HIDE_SCOPE_NAMES))
6860 {
6861 if (!funcType.isEmpty())
6862 {
6863 if (isFunc) // a function -> we use argList for the arguments
6864 {
6865 funcDecl=funcType+" "+tempScopeName+"::"+funcName+funcTempList;
6866 }
6867 else
6868 {
6869 funcDecl=funcType+" "+tempScopeName+"::"+funcName+funcArgs;
6870 }
6871 }
6872 else
6873 {
6874 if (isFunc) // a function => we use argList for the arguments
6875 {
6876 funcDecl=tempScopeName+"::"+funcName+funcTempList;
6877 }
6878 else // variable => add 'argument' list
6879 {
6880 funcDecl=tempScopeName+"::"+funcName+funcArgs;
6881 }
6882 }
6883 }
6884 else // build declaration without scope
6885 {
6886 if (!funcType.isEmpty()) // but with a type
6887 {
6888 if (isFunc) // function => omit argument list
6889 {
6890 funcDecl=funcType+" "+funcName+funcTempList;
6891 }
6892 else // variable => add 'argument' list
6893 {
6894 funcDecl=funcType+" "+funcName+funcArgs;
6895 }
6896 }
6897 else // no type
6898 {
6899 if (isFunc)
6900 {
6901 funcDecl=funcName+funcTempList;
6902 }
6903 else
6904 {
6905 funcDecl=funcName+funcArgs;
6906 }
6907 }
6908 }
6909
6910 if (funcType=="template class" && !funcTempList.isEmpty())
6911 return; // ignore explicit template instantiations
6912
6913 AUTO_TRACE_ADD("Parse results: namespaceName='{}' className=`{}` funcType='{}' funcSpec='{}' "
6914 " funcName='{}' funcArgs='{}' funcTempList='{}' funcDecl='{}' relates='{}'"
6915 " exceptions='{}' isRelated={} isMemberOf={} isFriend={} isFunc={}",
6916 namespaceName, className, funcType, funcSpec,
6917 funcName, funcArgs, funcTempList, funcDecl, relates,
6918 exceptions, isRelated, isMemberOf, isFriend, isFunc);
6919
6920 if (!funcName.isEmpty()) // function name is valid
6921 {
6922 // check if 'className' is actually a scoped enum, in which case we need to
6923 // process it as a global, see issue #6471
6924 bool strongEnum = false;
6925 MemberName *mn=nullptr;
6926 if (!className.isEmpty() && (mn=Doxygen::functionNameLinkedMap->find(className)))
6927 {
6928 for (const auto &imd : *mn)
6929 {
6930 MemberDefMutable *md = toMemberDefMutable(imd.get());
6931 Definition *mdScope = nullptr;
6932 if (md && md->isEnumerate() && md->isStrong() && (mdScope=md->getOuterScope()) &&
6933 // need filter for the correct scope, see issue #9668
6934 ((namespaceName.isEmpty() && mdScope==Doxygen::globalScope) || (mdScope->name()==namespaceName)))
6935 {
6936 AUTO_TRACE_ADD("'{}' is a strong enum! (namespace={} md->getOuterScope()->name()={})",md->name(),namespaceName,md->getOuterScope()->name());
6937 strongEnum = true;
6938 // pass the scope name name as a 'namespace' to the findGlobalMember function
6939 if (!namespaceName.isEmpty())
6940 {
6941 namespaceName+="::"+className;
6942 }
6943 else
6944 {
6945 namespaceName=className;
6946 }
6947 }
6948 }
6949 }
6950
6951 if (funcName.startsWith("operator ")) // strip class scope from cast operator
6952 {
6953 funcName = substitute(funcName,className+"::","");
6954 }
6955 mn = nullptr;
6956 if (!funcTempList.isEmpty()) // try with member specialization
6957 {
6958 mn=Doxygen::memberNameLinkedMap->find(funcName+funcTempList);
6959 }
6960 if (mn==nullptr) // try without specialization
6961 {
6962 mn=Doxygen::memberNameLinkedMap->find(funcName);
6963 }
6964 if (!isRelated && !strongEnum && mn) // function name already found
6965 {
6966 AUTO_TRACE_ADD("member name exists ({} members with this name)",mn->size());
6967 if (!className.isEmpty()) // class name is valid
6968 {
6969 if (funcSpec.isEmpty()) // not a member specialization
6970 {
6971 addMemberFunction(root,mn,scopeName,namespaceName,className,funcType,funcName,
6972 funcArgs,funcTempList,exceptions,
6973 type,args,isFriend,spec,relates,funcDecl,overloaded,isFunc);
6974 }
6975 else if (cd) // member specialization
6976 {
6977 addMemberSpecialization(root,mn,cd,funcType,funcName,funcArgs,funcDecl,exceptions,spec);
6978 }
6979 else
6980 {
6981 //printf("*** Specialized member %s of unknown scope %s%s found!\n",
6982 // qPrint(scopeName),qPrint(funcName),qPrint(funcArgs));
6983 }
6984 }
6985 else if (overloaded) // check if the function belongs to only one class
6986 {
6987 addOverloaded(root,mn,funcType,funcName,funcArgs,funcDecl,exceptions,spec);
6988 }
6989 else // unrelated function with the same name as a member
6990 {
6991 if (!findGlobalMember(root,namespaceName,funcType,funcName,funcTempList,funcArgs,funcDecl,spec))
6992 {
6993 QCString fullFuncDecl=funcDecl;
6994 if (isFunc) fullFuncDecl+=argListToString(root->argList,TRUE);
6995 warn(root->fileName,root->startLine,
6996 "Cannot determine class for function\n{}",
6997 fullFuncDecl
6998 );
6999 }
7000 }
7001 }
7002 else if (isRelated && !relates.isEmpty())
7003 {
7004 AUTO_TRACE_ADD("related function scopeName='{}' className='{}'",scopeName,className);
7005 if (className.isEmpty()) className=relates;
7006 //printf("scopeName='%s' className='%s'\n",qPrint(scopeName),qPrint(className));
7007 if ((cd=getClassMutable(scopeName)))
7008 {
7009 bool newMember=TRUE; // assume we have a new member
7010 MemberDefMutable *mdDefine=nullptr;
7011 {
7012 mn = Doxygen::functionNameLinkedMap->find(funcName);
7013 if (mn)
7014 {
7015 for (const auto &imd : *mn)
7016 {
7017 MemberDefMutable *md = toMemberDefMutable(imd.get());
7018 if (md && md->isDefine())
7019 {
7020 mdDefine = md;
7021 break;
7022 }
7023 }
7024 }
7025 }
7026
7027 if (mdDefine) // macro definition is already created by the preprocessor and inserted as a file member
7028 {
7029 //printf("moving #define %s into class %s\n",qPrint(mdDefine->name()),qPrint(cd->name()));
7030
7031 // take mdDefine from the Doxygen::functionNameLinkedMap (without deleting the data)
7032 auto mdDefineTaken = Doxygen::functionNameLinkedMap->take(funcName,mdDefine);
7033 // insert it as a class member
7034 if ((mn=Doxygen::memberNameLinkedMap->find(funcName))==nullptr)
7035 {
7036 mn=Doxygen::memberNameLinkedMap->add(funcName);
7037 }
7038
7039 if (mdDefine->getFileDef())
7040 {
7041 mdDefine->getFileDef()->removeMember(mdDefine);
7042 }
7043 mdDefine->makeRelated();
7044 mdDefine->setMemberClass(cd);
7045 mdDefine->moveTo(cd);
7046 cd->insertMember(mdDefine);
7047 // also insert the member as an alias in the parent's scope, so it can be referenced also without cd's scope
7048 insertMemberAlias(cd->getOuterScope(),mdDefine);
7049 mn->push_back(std::move(mdDefineTaken));
7050 }
7051 else // normal member, needs to be created and added to the class
7052 {
7053 FileDef *fd=root->fileDef();
7054
7055 if ((mn=Doxygen::memberNameLinkedMap->find(funcName))==nullptr)
7056 {
7057 mn=Doxygen::memberNameLinkedMap->add(funcName);
7058 }
7059 else
7060 {
7061 // see if we got another member with matching arguments
7062 MemberDefMutable *rmd_found = nullptr;
7063 for (const auto &irmd : *mn)
7064 {
7065 MemberDefMutable *rmd = toMemberDefMutable(irmd.get());
7066 if (rmd)
7067 {
7068 const ArgumentList &rmdAl = rmd->argumentList();
7069
7070 newMember=
7071 className!=rmd->getOuterScope()->name() ||
7072 !matchArguments2(rmd->getOuterScope(),rmd->getFileDef(),&rmdAl,
7073 cd,fd,&root->argList,
7074 TRUE,root->lang);
7075 if (!newMember)
7076 {
7077 rmd_found = rmd;
7078 }
7079 }
7080 }
7081 if (rmd_found) // member already exists as rmd -> add docs
7082 {
7083 AUTO_TRACE_ADD("addMemberDocs for related member {}",root->name);
7084 addMemberDocs(root,rmd_found,funcDecl,nullptr,overloaded,spec);
7085 newMember=false;
7086 }
7087 }
7088
7089 if (newMember) // need to create a new member
7090 {
7092 switch (root->mtype)
7093 {
7094 case MethodTypes::Method: mtype = MemberType::Function; break;
7095 case MethodTypes::Signal: mtype = MemberType::Signal; break;
7096 case MethodTypes::Slot: mtype = MemberType::Slot; break;
7097 case MethodTypes::DCOP: mtype = MemberType::DCOP; break;
7098 case MethodTypes::Property: mtype = MemberType::Property; break;
7099 case MethodTypes::Event: mtype = MemberType::Event; break;
7100 }
7101
7102 //printf("New related name '%s' '%d'\n",qPrint(funcName),
7103 // root->argList ? (int)root->argList->count() : -1);
7104
7105 // first note that we pass:
7106 // (root->tArgLists ? root->tArgLists->last() : nullptr)
7107 // for the template arguments for the new "member."
7108 // this accurately reflects the template arguments of
7109 // the related function, which don't have to do with
7110 // those of the related class.
7111 auto md = createMemberDef(
7112 root->fileName,root->startLine,root->startColumn,
7113 funcType,funcName,funcArgs,exceptions,
7114 root->protection,root->virt,
7115 root->isStatic,
7116 isMemberOf ? Relationship::Foreign : Relationship::Related,
7117 mtype,
7118 (!root->tArgLists.empty() ? root->tArgLists.back() : ArgumentList()),
7119 funcArgs.isEmpty() ? ArgumentList() : root->argList,
7120 root->metaData);
7121 auto mmd = toMemberDefMutable(md.get());
7122
7123 // also insert the member as an alias in the parent's scope, so it can be referenced also without cd's scope
7124 insertMemberAlias(cd->getOuterScope(),md.get());
7125
7126 // we still have the problem that
7127 // MemberDef::writeDocumentation() in memberdef.cpp
7128 // writes the template argument list for the class,
7129 // as if this member is a member of the class.
7130 // fortunately, MemberDef::writeDocumentation() has
7131 // a special mechanism that allows us to totally
7132 // override the set of template argument lists that
7133 // are printed. We use that and set it to the
7134 // template argument lists of the related function.
7135 //
7136 mmd->setDefinitionTemplateParameterLists(root->tArgLists);
7137
7138 mmd->setTagInfo(root->tagInfo());
7139
7140 //printf("Related member name='%s' decl='%s' bodyLine='%d'\n",
7141 // qPrint(funcName),qPrint(funcDecl),root->bodyLine);
7142
7143 // try to find the matching line number of the body from the
7144 // global function list
7145 bool found=FALSE;
7146 if (root->bodyLine==-1)
7147 {
7148 MemberName *rmn=Doxygen::functionNameLinkedMap->find(funcName);
7149 if (rmn)
7150 {
7151 const MemberDefMutable *rmd_found=nullptr;
7152 for (const auto &irmd : *rmn)
7153 {
7154 MemberDefMutable *rmd = toMemberDefMutable(irmd.get());
7155 if (rmd)
7156 {
7157 const ArgumentList &rmdAl = rmd->argumentList();
7158 // check for matching argument lists
7159 if (
7160 matchArguments2(rmd->getOuterScope(),rmd->getFileDef(),&rmdAl,
7161 cd,fd,&root->argList,
7162 TRUE,root->lang)
7163 )
7164 {
7165 found=TRUE;
7166 rmd_found = rmd;
7167 break;
7168 }
7169 }
7170 }
7171 if (rmd_found) // member found -> copy line number info
7172 {
7173 mmd->setBodySegment(rmd_found->getDefLine(),rmd_found->getStartBodyLine(),rmd_found->getEndBodyLine());
7174 mmd->setBodyDef(rmd_found->getBodyDef());
7175 //md->setBodyMember(rmd);
7176 }
7177 }
7178 }
7179 if (!found) // line number could not be found or is available in this
7180 // entry
7181 {
7182 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
7183 mmd->setBodyDef(fd);
7184 }
7185
7186 //if (root->mGrpId!=-1)
7187 //{
7188 // md->setMemberGroup(memberGroupDict[root->mGrpId]);
7189 //}
7190 mmd->setMemberClass(cd);
7191 mmd->setMemberSpecifiers(spec);
7192 mmd->setVhdlSpecifiers(root->vhdlSpec);
7193 mmd->setDefinition(funcDecl);
7195 mmd->addQualifiers(root->qualifiers);
7196 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
7197 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
7198 mmd->setDocsForDefinition(!root->proto);
7199 mmd->setPrototype(root->proto,root->fileName,root->startLine,root->startColumn);
7200 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
7201 mmd->addSectionsToDefinition(root->anchors);
7202 mmd->setMemberGroupId(root->mGrpId);
7203 mmd->setLanguage(root->lang);
7204 mmd->setId(root->id);
7205 //md->setMemberDefTemplateArguments(root->mtArgList);
7206 cd->insertMember(md.get());
7207 cd->insertUsedFile(fd);
7208 mmd->setRefItems(root->sli);
7209 if (root->relatesType==RelatesType::Duplicate) mmd->setRelatedAlso(cd);
7210 addMemberToGroups(root,md.get());
7212 //printf("Adding member=%s\n",qPrint(md->name()));
7213 mn->push_back(std::move(md));
7214 }
7215 if (root->relatesType==RelatesType::Duplicate)
7216 {
7217 if (!findGlobalMember(root,namespaceName,funcType,funcName,funcTempList,funcArgs,funcDecl,spec))
7218 {
7219 QCString fullFuncDecl=funcDecl;
7220 if (isFunc) fullFuncDecl+=argListToString(root->argList,TRUE);
7221 warn(root->fileName,root->startLine,
7222 "Cannot determine file/namespace for relatedalso function\n{}",
7223 fullFuncDecl
7224 );
7225 }
7226 }
7227 }
7228 }
7229 else
7230 {
7231 warn_undoc(root->fileName,root->startLine, "class '{}' for related function '{}' is not documented.", className,funcName);
7232 }
7233 }
7234 else if (root->parent() && root->parent()->section.isObjcImpl())
7235 {
7236 addLocalObjCMethod(root,scopeName,funcType,funcName,funcArgs,exceptions,funcDecl,spec);
7237 }
7238 else // unrelated not overloaded member found
7239 {
7240 bool globMem = findGlobalMember(root,namespaceName,funcType,funcName,funcTempList,funcArgs,funcDecl,spec);
7241 if (className.isEmpty() && !globMem)
7242 {
7243 warn(root->fileName,root->startLine, "class for member '{}' cannot be found.", funcName);
7244 }
7245 else if (!className.isEmpty() && !globMem)
7246 {
7247 warn(root->fileName,root->startLine,
7248 "member '{}' of class '{}' cannot be found",
7249 funcName,className);
7250 }
7251 }
7252 }
7253 else
7254 {
7255 // this should not be called
7256 warn(root->fileName,root->startLine,"member with no name found.");
7257 }
7258 return;
7259}
7260
7261//----------------------------------------------------------------------
7262// find the members corresponding to the different documentation blocks
7263// that are extracted from the sources.
7264
7265static void filterMemberDocumentation(const Entry *root,const QCString &relates)
7266{
7267 AUTO_TRACE("root->type='{}' root->inside='{}' root->name='{}' root->args='{}' section={} root->spec={} root->mGrpId={}",
7268 root->type,root->inside,root->name,root->args,root->section,root->spec,root->mGrpId);
7269 //printf("root->parent()->name=%s\n",qPrint(root->parent()->name));
7270 bool isFunc=TRUE;
7271
7272 QCString type = root->type;
7273 QCString args = root->args;
7274 int i=-1, l=0;
7275 if ( // detect func variable/typedef to func ptr
7276 (i=findFunctionPtr(type.str(),root->lang,&l))!=-1
7277 )
7278 {
7279 //printf("Fixing function pointer!\n");
7280 // fix type and argument
7281 args.prepend(type.right(type.length()-i-l));
7282 type=type.left(i+l);
7283 //printf("Results type=%s,name=%s,args=%s\n",qPrint(type),qPrint(root->name),qPrint(args));
7284 isFunc=FALSE;
7285 }
7286 else if ((type.startsWith("typedef ") && args.find('(')!=-1))
7287 // detect function types marked as functions
7288 {
7289 isFunc=FALSE;
7290 }
7291
7292 //printf("Member %s isFunc=%d\n",qPrint(root->name),isFunc);
7293 if (root->section.isMemberDoc())
7294 {
7295 //printf("Documentation for inline member '%s' found args='%s'\n",
7296 // qPrint(root->name),qPrint(args));
7297 //if (relates.length()) printf(" Relates %s\n",qPrint(relates));
7298 if (type.isEmpty())
7299 {
7300 findMember(root,
7301 relates,
7302 type,
7303 args,
7304 root->name + args + root->exception,
7305 FALSE,
7306 isFunc);
7307 }
7308 else
7309 {
7310 findMember(root,
7311 relates,
7312 type,
7313 args,
7314 type + " " + root->name + args + root->exception,
7315 FALSE,
7316 isFunc);
7317 }
7318 }
7319 else if (root->section.isOverloadDoc())
7320 {
7321 //printf("Overloaded member %s found\n",qPrint(root->name));
7322 findMember(root,
7323 relates,
7324 type,
7325 args,
7326 root->name,
7327 TRUE,
7328 isFunc);
7329 }
7330 else if
7331 ((root->section.isFunction() // function
7332 ||
7333 (root->section.isVariable() && // variable
7334 !type.isEmpty() && // with a type
7335 g_compoundKeywords.find(type.str())==g_compoundKeywords.end() // that is not a keyword
7336 // (to skip forward declaration of class etc.)
7337 )
7338 )
7339 )
7340 {
7341 //printf("Documentation for member '%s' found args='%s' excp='%s'\n",
7342 // qPrint(root->name),qPrint(args),qPrint(root->exception));
7343 //if (relates.length()) printf(" Relates %s\n",qPrint(relates));
7344 //printf("Inside=%s\n Relates=%s\n",qPrint(root->inside),qPrint(relates));
7345 if (type=="friend class" || type=="friend struct" ||
7346 type=="friend union")
7347 {
7348 findMember(root,
7349 relates,
7350 type,
7351 args,
7352 type+" "+root->name,
7353 FALSE,FALSE);
7354
7355 }
7356 else if (!type.isEmpty())
7357 {
7358 findMember(root,
7359 relates,
7360 type,
7361 args,
7362 type+" "+ root->inside + root->name + args + root->exception,
7363 FALSE,isFunc);
7364 }
7365 else
7366 {
7367 findMember(root,
7368 relates,
7369 type,
7370 args,
7371 root->inside + root->name + args + root->exception,
7372 FALSE,isFunc);
7373 }
7374 }
7375 else if (root->section.isDefine() && !relates.isEmpty())
7376 {
7377 findMember(root,
7378 relates,
7379 type,
7380 args,
7381 root->name + args,
7382 FALSE,
7383 !args.isEmpty());
7384 }
7385 else if (root->section.isVariableDoc())
7386 {
7387 //printf("Documentation for variable %s found\n",qPrint(root->name));
7388 //if (!relates.isEmpty()) printf(" Relates %s\n",qPrint(relates));
7389 findMember(root,
7390 relates,
7391 type,
7392 args,
7393 root->name,
7394 FALSE,
7395 FALSE);
7396 }
7397 else if (root->section.isExportedInterface() ||
7398 root->section.isIncludedService())
7399 {
7400 findMember(root,
7401 relates,
7402 type,
7403 args,
7404 type + " " + root->name,
7405 FALSE,
7406 FALSE);
7407 }
7408 else
7409 {
7410 // skip section
7411 //printf("skip section\n");
7412 }
7413}
7414
7415static void findMemberDocumentation(const Entry *root)
7416{
7417 if (root->section.isMemberDoc() ||
7418 root->section.isOverloadDoc() ||
7419 root->section.isFunction() ||
7420 root->section.isVariable() ||
7421 root->section.isVariableDoc() ||
7422 root->section.isDefine() ||
7423 root->section.isIncludedService() ||
7424 root->section.isExportedInterface()
7425 )
7426 {
7427 AUTO_TRACE();
7428 if (root->relatesType==RelatesType::Duplicate && !root->relates.isEmpty())
7429 {
7431 }
7433 }
7434 for (const auto &e : root->children())
7435 {
7436 if (!e->section.isEnum())
7437 {
7438 findMemberDocumentation(e.get());
7439 }
7440 }
7441}
7442
7443//----------------------------------------------------------------------
7444
7445static void findObjCMethodDefinitions(const Entry *root)
7446{
7447 AUTO_TRACE();
7448 for (const auto &objCImpl : root->children())
7449 {
7450 if (objCImpl->section.isObjcImpl())
7451 {
7452 for (const auto &objCMethod : objCImpl->children())
7453 {
7454 if (objCMethod->section.isFunction())
7455 {
7456 //printf(" Found ObjC method definition %s\n",qPrint(objCMethod->name));
7457 findMember(objCMethod.get(),
7458 objCMethod->relates,
7459 objCMethod->type,
7460 objCMethod->args,
7461 objCMethod->type+" "+objCImpl->name+"::"+objCMethod->name+" "+objCMethod->args,
7462 FALSE,TRUE);
7463 objCMethod->section=EntryType::makeEmpty();
7464 }
7465 }
7466 }
7467 }
7468}
7469
7470//----------------------------------------------------------------------
7471// find and add the enumeration to their classes, namespaces or files
7472
7473static void findEnums(const Entry *root)
7474{
7475 if (root->section.isEnum())
7476 {
7477 AUTO_TRACE("name={}",root->name);
7478 ClassDefMutable *cd = nullptr;
7479 FileDef *fd = nullptr;
7480 NamespaceDefMutable *nd = nullptr;
7481 MemberNameLinkedMap *mnsd = nullptr;
7482 bool isGlobal = false;
7483 bool isRelated = false;
7484 bool isMemberOf = false;
7485 //printf("Found enum with name '%s' relates=%s\n",qPrint(root->name),qPrint(root->relates));
7486
7487 QCString name;
7488 QCString scope;
7489
7490 int i = root->name.findRev("::");
7491 if (i!=-1) // scope is specified
7492 {
7493 scope=root->name.left(i); // extract scope
7494 if (root->lang==SrcLangExt::CSharp)
7495 {
7496 scope = mangleCSharpGenericName(scope);
7497 }
7498 name=root->name.right(root->name.length()-i-2); // extract name
7499 if ((cd=getClassMutable(scope))==nullptr)
7500 {
7502 }
7503 }
7504 else // no scope, check the scope in which the docs where found
7505 {
7506 if (root->parent()->section.isScope() && !root->parent()->name.isEmpty()) // found enum docs inside a compound
7507 {
7508 scope=root->parent()->name;
7509 if ((cd=getClassMutable(scope))==nullptr) nd=getResolvedNamespaceMutable(scope);
7510 }
7511 name=root->name;
7512 }
7513
7514 if (!root->relates.isEmpty())
7515 { // related member, prefix user specified scope
7516 isRelated=TRUE;
7517 isMemberOf=(root->relatesType==RelatesType::MemberOf);
7518 if (getClass(root->relates)==nullptr && !scope.isEmpty())
7519 scope=mergeScopes(scope,root->relates);
7520 else
7521 scope=root->relates;
7522 if ((cd=getClassMutable(scope))==nullptr) nd=getResolvedNamespaceMutable(scope);
7523 }
7524
7525 if (cd && !name.isEmpty()) // found a enum inside a compound
7526 {
7527 //printf("Enum '%s'::'%s'\n",qPrint(cd->name()),qPrint(name));
7528 fd=nullptr;
7530 isGlobal=false;
7531 }
7532 else if (nd) // found enum inside namespace
7533 {
7535 isGlobal=true;
7536 }
7537 else // found a global enum
7538 {
7539 fd=root->fileDef();
7541 isGlobal=true;
7542 }
7543
7544 if (!name.isEmpty())
7545 {
7546 // new enum type
7547 AUTO_TRACE_ADD("new enum {} at line {} of {}",name,root->bodyLine,root->fileName);
7548 auto md = createMemberDef(
7549 root->fileName,root->startLine,root->startColumn,
7550 QCString(),name,QCString(),QCString(),
7551 root->protection,Specifier::Normal,FALSE,
7552 isMemberOf ? Relationship::Foreign : isRelated ? Relationship::Related : Relationship::Member,
7555 auto mmd = toMemberDefMutable(md.get());
7556 mmd->setTagInfo(root->tagInfo());
7557 mmd->setLanguage(root->lang);
7558 mmd->setId(root->id);
7559 if (!isGlobal) mmd->setMemberClass(cd); else mmd->setFileDef(fd);
7560 mmd->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
7561 mmd->setBodyDef(root->fileDef());
7562 mmd->setMemberSpecifiers(root->spec);
7563 mmd->setVhdlSpecifiers(root->vhdlSpec);
7564 mmd->setEnumBaseType(root->args);
7565 //printf("Enum %s definition at line %d of %s: protection=%d scope=%s\n",
7566 // qPrint(root->name),root->bodyLine,qPrint(root->fileName),root->protection,cd?qPrint(cd->name()):"<none>");
7567 mmd->addSectionsToDefinition(root->anchors);
7568 mmd->setMemberGroupId(root->mGrpId);
7570 mmd->addQualifiers(root->qualifiers);
7571 //printf("%s::setRefItems(%zu)\n",qPrint(md->name()),root->sli.size());
7572 mmd->setRefItems(root->sli);
7573 //printf("found enum %s nd=%p\n",qPrint(md->name()),nd);
7574 bool defSet=FALSE;
7575
7576 QCString baseType = root->args;
7577 if (!baseType.isEmpty())
7578 {
7579 baseType.prepend(" : ");
7580 }
7581
7582 if (nd)
7583 {
7584 if (isRelated || Config_getBool(HIDE_SCOPE_NAMES))
7585 {
7586 mmd->setDefinition(name+baseType);
7587 }
7588 else
7589 {
7590 mmd->setDefinition(nd->name()+"::"+name+baseType);
7591 }
7592 //printf("definition=%s\n",md->definition());
7593 defSet=TRUE;
7594 mmd->setNamespace(nd);
7595 nd->insertMember(md.get());
7596 }
7597
7598 // even if we have already added the enum to a namespace, we still
7599 // also want to add it to other appropriate places such as file
7600 // or class.
7601 if (isGlobal && (nd==nullptr || !nd->isAnonymous()))
7602 {
7603 if (!defSet) mmd->setDefinition(name+baseType);
7604 if (fd==nullptr && root->parent())
7605 {
7606 fd=root->parent()->fileDef();
7607 }
7608 if (fd)
7609 {
7610 mmd->setFileDef(fd);
7611 fd->insertMember(md.get());
7612 }
7613 }
7614 else if (cd)
7615 {
7616 if (isRelated || Config_getBool(HIDE_SCOPE_NAMES))
7617 {
7618 mmd->setDefinition(name+baseType);
7619 }
7620 else
7621 {
7622 mmd->setDefinition(cd->name()+"::"+name+baseType);
7623 }
7624 cd->insertMember(md.get());
7625 cd->insertUsedFile(fd);
7626 }
7627 mmd->setDocumentation(root->doc,root->docFile,root->docLine);
7628 mmd->setDocsForDefinition(!root->proto);
7629 mmd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
7630 mmd->setInbodyDocumentation(root->inbodyDocs,root->inbodyFile,root->inbodyLine);
7631
7632 //printf("Adding member=%s\n",qPrint(md->name()));
7633 addMemberToGroups(root,md.get());
7635
7636 MemberName *mn = mnsd->add(name);
7637 mn->push_back(std::move(md));
7638 }
7639 }
7640 else
7641 {
7642 for (const auto &e : root->children()) findEnums(e.get());
7643 }
7644}
7645
7646//----------------------------------------------------------------------
7647
7648static void addEnumValuesToEnums(const Entry *root)
7649{
7650 if (root->section.isEnum())
7651 // non anonymous enumeration
7652 {
7653 AUTO_TRACE("name={}",root->name);
7654 ClassDefMutable *cd = nullptr;
7655 FileDef *fd = nullptr;
7656 NamespaceDefMutable *nd = nullptr;
7657 MemberNameLinkedMap *mnsd = nullptr;
7658 bool isGlobal = false;
7659 bool isRelated = false;
7660 //printf("Found enum with name '%s' relates=%s\n",qPrint(root->name),qPrint(root->relates));
7661
7662 QCString name;
7663 QCString scope;
7664
7665 int i = root->name.findRev("::");
7666 if (i!=-1) // scope is specified
7667 {
7668 scope=root->name.left(i); // extract scope
7669 if (root->lang==SrcLangExt::CSharp)
7670 {
7671 scope = mangleCSharpGenericName(scope);
7672 }
7673 name=root->name.right(root->name.length()-i-2); // extract name
7674 if ((cd=getClassMutable(scope))==nullptr)
7675 {
7677 }
7678 }
7679 else // no scope, check the scope in which the docs where found
7680 {
7681 if (root->parent()->section.isScope() && !root->parent()->name.isEmpty()) // found enum docs inside a compound
7682 {
7683 scope=root->parent()->name;
7684 if (root->lang==SrcLangExt::CSharp)
7685 {
7686 scope = mangleCSharpGenericName(scope);
7687 }
7688 if ((cd=getClassMutable(scope))==nullptr) nd=getResolvedNamespaceMutable(scope);
7689 }
7690 name=root->name;
7691 }
7692
7693 if (!root->relates.isEmpty())
7694 { // related member, prefix user specified scope
7695 isRelated=TRUE;
7696 if (getClassMutable(root->relates)==nullptr && !scope.isEmpty())
7697 scope=mergeScopes(scope,root->relates);
7698 else
7699 scope=root->relates;
7700 if ((cd=getClassMutable(scope))==nullptr) nd=getResolvedNamespaceMutable(scope);
7701 }
7702
7703 if (cd && !name.isEmpty()) // found a enum inside a compound
7704 {
7705 //printf("Enum in class '%s'::'%s'\n",qPrint(cd->name()),qPrint(name));
7706 fd=nullptr;
7708 isGlobal=false;
7709 }
7710 else if (nd && !nd->isAnonymous()) // found enum inside namespace
7711 {
7712 //printf("Enum in namespace '%s'::'%s'\n",qPrint(nd->name()),qPrint(name));
7714 isGlobal=true;
7715 }
7716 else // found a global enum
7717 {
7718 fd=root->fileDef();
7719 //printf("Enum in file '%s': '%s'\n",qPrint(fd->name()),qPrint(name));
7721 isGlobal=true;
7722 }
7723
7724 if (!name.isEmpty())
7725 {
7726 //printf("** name=%s\n",qPrint(name));
7727 MemberName *mn = mnsd->find(name); // for all members with this name
7728 if (mn)
7729 {
7730 struct EnumValueInfo
7731 {
7732 EnumValueInfo(const QCString &n,std::unique_ptr<MemberDef> &&md) :
7733 name(n), member(std::move(md)) {}
7734 QCString name;
7735 std::unique_ptr<MemberDef> member;
7736 };
7737 std::vector< EnumValueInfo > extraMembers;
7738 // for each enum in this list
7739 for (const auto &imd : *mn)
7740 {
7741 MemberDefMutable *md = toMemberDefMutable(imd.get());
7742 // use raw pointer in this loop, since we modify mn and can then invalidate mdp.
7743 if (md && md->isEnumerate() && !root->children().empty())
7744 {
7745 AUTO_TRACE_ADD("enum {} with {} children",md->name(),root->children().size());
7746 for (const auto &e : root->children())
7747 {
7748 SrcLangExt sle = root->lang;
7749 bool isJavaLike = sle==SrcLangExt::CSharp || sle==SrcLangExt::Java || sle==SrcLangExt::XML;
7750 if ( isJavaLike || root->spec.isStrong())
7751 {
7752 if (sle == SrcLangExt::Cpp && e->section.isDefine()) continue;
7753 // Unlike classic C/C++ enums, for C++11, C# & Java enum
7754 // values are only visible inside the enum scope, so we must create
7755 // them here and only add them to the enum
7756 //printf("md->qualifiedName()=%s e->name=%s tagInfo=%p name=%s\n",
7757 // qPrint(md->qualifiedName()),qPrint(e->name),(void*)e->tagInfo(),qPrint(e->name));
7758 QCString qualifiedName = root->name;
7759 i = qualifiedName.findRev("::");
7760 if (i!=-1 && sle==SrcLangExt::CSharp)
7761 {
7762 qualifiedName = mangleCSharpGenericName(qualifiedName.left(i))+qualifiedName.mid(i);
7763 }
7764 if (isJavaLike)
7765 {
7766 qualifiedName=substitute(qualifiedName,"::",".");
7767 }
7768 if (md->qualifiedName()==qualifiedName) // enum value scope matches that of the enum
7769 {
7770 QCString fileName = e->fileName;
7771 if (fileName.isEmpty() && e->tagInfo())
7772 {
7773 fileName = e->tagInfo()->tagName;
7774 }
7775 AUTO_TRACE_ADD("strong enum value {}",e->name);
7776 auto fmd = createMemberDef(
7777 fileName,e->startLine,e->startColumn,
7778 e->type,e->name,e->args,QCString(),
7779 e->protection, Specifier::Normal,e->isStatic,Relationship::Member,
7781 auto fmmd = toMemberDefMutable(fmd.get());
7782 NamespaceDef *mnd = md->getNamespaceDef();
7783 if (md->getClassDef())
7784 fmmd->setMemberClass(md->getClassDef());
7785 else if (mnd && (mnd->isLinkable() || mnd->isAnonymous()))
7786 fmmd->setNamespace(mnd);
7787 else if (md->getFileDef())
7788 fmmd->setFileDef(md->getFileDef());
7789 fmmd->setOuterScope(md->getOuterScope());
7790 fmmd->setTagInfo(e->tagInfo());
7791 fmmd->setLanguage(e->lang);
7792 fmmd->setBodySegment(e->startLine,e->bodyLine,e->endBodyLine);
7793 fmmd->setBodyDef(e->fileDef());
7794 fmmd->setId(e->id);
7795 fmmd->setDocumentation(e->doc,e->docFile,e->docLine);
7796 fmmd->setBriefDescription(e->brief,e->briefFile,e->briefLine);
7797 fmmd->addSectionsToDefinition(e->anchors);
7798 std::string init = e->initializer.str();
7799 fmmd->setInitializer(init.c_str());
7800 fmmd->setMaxInitLines(e->initLines);
7801 fmmd->setMemberGroupId(e->mGrpId);
7802 fmmd->setExplicitExternal(e->explicitExternal,fileName,e->startLine,e->startColumn);
7803 fmmd->setRefItems(e->sli);
7804 fmmd->setAnchor();
7805 md->insertEnumField(fmd.get());
7806 fmmd->setEnumScope(md,TRUE);
7807 extraMembers.emplace_back(e->name,std::move(fmd));
7808 }
7809 }
7810 else
7811 {
7812 AUTO_TRACE_ADD("enum value {}",e->name);
7813 //printf("e->name=%s isRelated=%d\n",qPrint(e->name),isRelated);
7814 MemberName *fmn=nullptr;
7815 MemberNameLinkedMap *emnsd = isRelated ? Doxygen::functionNameLinkedMap : mnsd;
7816 if (!e->name.isEmpty() && (fmn=emnsd->find(e->name)))
7817 // get list of members with the same name as the field
7818 {
7819 for (const auto &ifmd : *fmn)
7820 {
7821 MemberDefMutable *fmd = toMemberDefMutable(ifmd.get());
7822 if (fmd && fmd->isEnumValue() && fmd->getOuterScope()==md->getOuterScope()) // in same scope
7823 {
7824 //printf("found enum value with same name %s in scope %s\n",
7825 // qPrint(fmd->name()),qPrint(fmd->getOuterScope()->name()));
7826 if (nd && !nd->isAnonymous())
7827 {
7828 if (!fmd->isStrongEnumValue()) // only non strong enum values can be globally added
7829 {
7830 const NamespaceDef *fnd=fmd->getNamespaceDef();
7831 if (fnd==nd) // enum value is inside a namespace
7832 {
7833 md->insertEnumField(fmd);
7834 fmd->setEnumScope(md);
7835 }
7836 }
7837 }
7838 else if (isGlobal)
7839 {
7840 if (!fmd->isStrongEnumValue()) // only non strong enum values can be globally added
7841 {
7842 const FileDef *ffd=fmd->getFileDef();
7843 if (ffd==fd && ffd==md->getFileDef()) // enum value has file scope
7844 {
7845 md->insertEnumField(fmd);
7846 fmd->setEnumScope(md);
7847 }
7848 }
7849 }
7850 else if (isRelated && cd) // reparent enum value to
7851 // match the enum's scope
7852 {
7853 md->insertEnumField(fmd); // add field def to list
7854 fmd->setEnumScope(md); // cross ref with enum name
7855 fmd->setEnumClassScope(cd); // cross ref with enum name
7856 fmd->setOuterScope(cd);
7857 fmd->makeRelated();
7858 cd->insertMember(fmd);
7859 }
7860 else
7861 {
7862 if (!fmd->isStrongEnumValue()) // only non strong enum values can be globally added
7863 {
7864 const ClassDef *fcd=fmd->getClassDef();
7865 if (fcd==cd) // enum value is inside a class
7866 {
7867 //printf("Inserting enum field %s in enum scope %s\n",
7868 // qPrint(fmd->name()),qPrint(md->name()));
7869 md->insertEnumField(fmd); // add field def to list
7870 fmd->setEnumScope(md); // cross ref with enum name
7871 }
7872 }
7873 }
7874 }
7875 }
7876 }
7877 }
7878 }
7879 }
7880 }
7881 // move the newly added members into mn
7882 for (auto &e : extraMembers)
7883 {
7884 MemberName *emn=mnsd->add(e.name);
7885 emn->push_back(std::move(e.member));
7886 }
7887 }
7888 }
7889 }
7890 else
7891 {
7892 for (const auto &e : root->children()) addEnumValuesToEnums(e.get());
7893 }
7894}
7895
7896//----------------------------------------------------------------------
7897
7898static void addEnumDocs(const Entry *root,MemberDefMutable *md)
7899{
7900 AUTO_TRACE();
7901 // documentation outside a compound overrides the documentation inside it
7902 {
7903 md->setDocumentation(root->doc,root->docFile,root->docLine);
7904 md->setDocsForDefinition(!root->proto);
7905 }
7906
7907 // brief descriptions inside a compound override the documentation
7908 // outside it
7909 {
7910 md->setBriefDescription(root->brief,root->briefFile,root->briefLine);
7911 }
7912
7913 if (md->inbodyDocumentation().isEmpty() || !root->parent()->name.isEmpty())
7914 {
7916 }
7917
7918 if (root->mGrpId!=-1 && md->getMemberGroupId()==-1)
7919 {
7920 md->setMemberGroupId(root->mGrpId);
7921 }
7922
7924 md->setRefItems(root->sli);
7925
7926 const GroupDef *gd=md->getGroupDef();
7927 if (gd==nullptr && !root->groups.empty()) // member not grouped but out-of-line documentation is
7928 {
7929 addMemberToGroups(root,md);
7930 }
7932}
7933
7934//----------------------------------------------------------------------
7935// Search for the name in the associated groups. If a matching member
7936// definition exists, then add the documentation to it and return TRUE,
7937// otherwise FALSE.
7938
7939static bool tryAddEnumDocsToGroupMember(const Entry *root,const QCString &name)
7940{
7941 for (const auto &g : root->groups)
7942 {
7943 const GroupDef *gd = Doxygen::groupLinkedMap->find(g.groupname);
7944 if (gd)
7945 {
7946 MemberList *ml = gd->getMemberList(MemberListType::DecEnumMembers());
7947 if (ml)
7948 {
7949 MemberDefMutable *md = toMemberDefMutable(ml->find(name));
7950 if (md)
7951 {
7952 addEnumDocs(root,md);
7953 return TRUE;
7954 }
7955 }
7956 }
7957 else if (!gd && g.pri == Grouping::GROUPING_INGROUP)
7958 {
7959 warn(root->fileName, root->startLine,
7960 "Found non-existing group '{}' for the command '{}', ignoring command",
7961 g.groupname, Grouping::getGroupPriName( g.pri )
7962 );
7963 }
7964 }
7965
7966 return FALSE;
7967}
7968
7969//----------------------------------------------------------------------
7970// find the documentation blocks for the enumerations
7971
7972static void findEnumDocumentation(const Entry *root)
7973{
7974 if (root->section.isEnumDoc() &&
7975 !root->name.isEmpty() &&
7976 root->name.at(0)!='@' // skip anonymous enums
7977 )
7978 {
7979 QCString name;
7980 QCString scope;
7981 int i = root->name.findRev("::");
7982 if (i!=-1) // scope is specified as part of the name
7983 {
7984 name=root->name.right(root->name.length()-i-2); // extract name
7985 scope=root->name.left(i); // extract scope
7986 //printf("Scope='%s' Name='%s'\n",qPrint(scope),qPrint(name));
7987 }
7988 else // just the name
7989 {
7990 name=root->name;
7991 }
7992 if (root->parent()->section.isScope() && !root->parent()->name.isEmpty()) // found enum docs inside a compound
7993 {
7994 if (!scope.isEmpty()) scope.prepend("::");
7995 scope.prepend(root->parent()->name);
7996 }
7997 const ClassDef *cd = getClass(scope);
7998 const NamespaceDef *nd=Doxygen::namespaceLinkedMap->find(scope);
7999 const FileDef *fd = root->fileDef();
8000 AUTO_TRACE("Found docs for enum with name '{}' and scope '{}' in context '{}' cd='{}', nd='{}' fd='{}'",
8001 name,scope,root->parent()->name,
8002 cd ? cd->name() : QCString("<none>"),
8003 nd ? nd->name() : QCString("<none>"),
8004 fd ? fd->name() : QCString("<none>"));
8005
8006 if (!name.isEmpty())
8007 {
8008 bool found = tryAddEnumDocsToGroupMember(root, name);
8009 if (!found)
8010 {
8011 MemberName *mn = cd ? Doxygen::memberNameLinkedMap->find(name) : Doxygen::functionNameLinkedMap->find(name);
8012 if (mn)
8013 {
8014 for (const auto &imd : *mn)
8015 {
8016 MemberDefMutable *md = toMemberDefMutable(imd.get());
8017 if (md && md->isEnumerate())
8018 {
8019 const ClassDef *mcd = md->getClassDef();
8020 const NamespaceDef *mnd = md->getNamespaceDef();
8021 const FileDef *mfd = md->getFileDef();
8022 if (cd && mcd==cd)
8023 {
8024 AUTO_TRACE_ADD("Match found for class scope");
8025 addEnumDocs(root,md);
8026 found = TRUE;
8027 break;
8028 }
8029 else if (cd==nullptr && mcd==nullptr && nd!=nullptr && mnd==nd)
8030 {
8031 AUTO_TRACE_ADD("Match found for namespace scope");
8032 addEnumDocs(root,md);
8033 found = TRUE;
8034 break;
8035 }
8036 else if (cd==nullptr && nd==nullptr && mcd==nullptr && mnd==nullptr && fd==mfd)
8037 {
8038 AUTO_TRACE_ADD("Match found for global scope");
8039 addEnumDocs(root,md);
8040 found = TRUE;
8041 break;
8042 }
8043 }
8044 }
8045 }
8046 }
8047 if (!found)
8048 {
8049 warn(root->fileName,root->startLine, "Documentation for undefined enum '{}' found.", name);
8050 }
8051 }
8052 }
8053 for (const auto &e : root->children()) findEnumDocumentation(e.get());
8054}
8055
8056// search for each enum (member or function) in mnl if it has documented
8057// enum values.
8058static void findDEV(const MemberNameLinkedMap &mnsd)
8059{
8060 // for each member name
8061 for (const auto &mn : mnsd)
8062 {
8063 // for each member definition
8064 for (const auto &imd : *mn)
8065 {
8066 MemberDefMutable *md = toMemberDefMutable(imd.get());
8067 if (md && md->isEnumerate()) // member is an enum
8068 {
8069 int documentedEnumValues=0;
8070 // for each enum value
8071 for (const auto &fmd : md->enumFieldList())
8072 {
8073 if (fmd->isLinkableInProject()) documentedEnumValues++;
8074 }
8075 // at least one enum value is documented
8076 if (documentedEnumValues>0) md->setDocumentedEnumValues(TRUE);
8077 }
8078 }
8079 }
8080}
8081
8082// search for each enum (member or function) if it has documented enum
8083// values.
8089
8090//----------------------------------------------------------------------
8091
8093{
8094 auto &index = Index::instance();
8095 // for each class member name
8096 for (const auto &mn : *Doxygen::memberNameLinkedMap)
8097 {
8098 // for each member definition
8099 for (const auto &md : *mn)
8100 {
8101 index.addClassMemberNameToIndex(md.get());
8102 if (md->getModuleDef())
8103 {
8104 index.addModuleMemberNameToIndex(md.get());
8105 }
8106 }
8107 }
8108 // for each file/namespace function name
8109 for (const auto &mn : *Doxygen::functionNameLinkedMap)
8110 {
8111 // for each member definition
8112 for (const auto &md : *mn)
8113 {
8114 if (md->getNamespaceDef())
8115 {
8116 index.addNamespaceMemberNameToIndex(md.get());
8117 }
8118 else
8119 {
8120 index.addFileMemberNameToIndex(md.get());
8121 }
8122 if (md->getModuleDef())
8123 {
8124 index.addModuleMemberNameToIndex(md.get());
8125 }
8126 }
8127 }
8128
8129 index.sortMemberIndexLists();
8130}
8131
8132//----------------------------------------------------------------------
8133
8134static void addToIndices()
8135{
8136 for (const auto &cd : *Doxygen::classLinkedMap)
8137 {
8138 if (cd->isLinkableInProject())
8139 {
8140 Doxygen::indexList->addIndexItem(cd.get(),nullptr);
8141 if (Doxygen::searchIndex.enabled())
8142 {
8143 Doxygen::searchIndex.setCurrentDoc(cd.get(),cd->anchor(),FALSE);
8144 Doxygen::searchIndex.addWord(cd->localName(),TRUE);
8145 }
8146 }
8147 }
8148
8149 for (const auto &cd : *Doxygen::conceptLinkedMap)
8150 {
8151 if (cd->isLinkableInProject())
8152 {
8153 Doxygen::indexList->addIndexItem(cd.get(),nullptr);
8154 if (Doxygen::searchIndex.enabled())
8155 {
8156 Doxygen::searchIndex.setCurrentDoc(cd.get(),cd->anchor(),FALSE);
8157 Doxygen::searchIndex.addWord(cd->localName(),TRUE);
8158 }
8159 }
8160 }
8161
8162 for (const auto &nd : *Doxygen::namespaceLinkedMap)
8163 {
8164 if (nd->isLinkableInProject())
8165 {
8166 Doxygen::indexList->addIndexItem(nd.get(),nullptr);
8167 if (Doxygen::searchIndex.enabled())
8168 {
8169 Doxygen::searchIndex.setCurrentDoc(nd.get(),nd->anchor(),FALSE);
8170 Doxygen::searchIndex.addWord(nd->localName(),TRUE);
8171 }
8172 }
8173 }
8174
8175 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8176 {
8177 for (const auto &fd : *fn)
8178 {
8179 if (Doxygen::searchIndex.enabled() && fd->isLinkableInProject())
8180 {
8181 Doxygen::searchIndex.setCurrentDoc(fd.get(),fd->anchor(),FALSE);
8182 Doxygen::searchIndex.addWord(fd->localName(),TRUE);
8183 }
8184 }
8185 }
8186
8187 auto addWordsForTitle = [](const Definition *d,const QCString &anchor,const QCString &title)
8188 {
8189 Doxygen::indexList->addIndexItem(d,nullptr,QCString(),filterTitle(title));
8190 if (Doxygen::searchIndex.enabled())
8191 {
8192 Doxygen::searchIndex.setCurrentDoc(d,anchor,false);
8193 std::string s = title.str();
8194 static const reg::Ex re(R"(\a[\w-]*)");
8195 reg::Iterator it(s,re);
8197 for (; it!=end ; ++it)
8198 {
8199 const auto &match = *it;
8200 std::string matchStr = match.str();
8201 Doxygen::searchIndex.addWord(matchStr.c_str(),true);
8202 }
8203 }
8204 };
8205
8206 for (const auto &gd : *Doxygen::groupLinkedMap)
8207 {
8208 if (gd->isLinkableInProject())
8209 {
8210 addWordsForTitle(gd.get(),gd->anchor(),gd->groupTitle());
8211 }
8212 }
8213
8214 for (const auto &pd : *Doxygen::pageLinkedMap)
8215 {
8216 if (pd->isLinkableInProject())
8217 {
8218 addWordsForTitle(pd.get(),pd->anchor(),pd->title());
8219 }
8220 }
8221
8223 {
8224 addWordsForTitle(Doxygen::mainPage.get(),Doxygen::mainPage->anchor(),Doxygen::mainPage->title());
8225 }
8226
8227 auto addMemberToSearchIndex = [](const MemberDef *md)
8228 {
8229 if (Doxygen::searchIndex.enabled())
8230 {
8231 Doxygen::searchIndex.setCurrentDoc(md,md->anchor(),FALSE);
8232 QCString ln=md->localName();
8233 QCString qn=md->qualifiedName();
8234 Doxygen::searchIndex.addWord(ln,TRUE);
8235 if (ln!=qn)
8236 {
8237 Doxygen::searchIndex.addWord(qn,TRUE);
8238 if (md->getClassDef())
8239 {
8240 Doxygen::searchIndex.addWord(md->getClassDef()->displayName(),TRUE);
8241 }
8242 if (md->getNamespaceDef())
8243 {
8244 Doxygen::searchIndex.addWord(md->getNamespaceDef()->displayName(),TRUE);
8245 }
8246 }
8247 }
8248 };
8249
8250 auto getScope = [](const MemberDef *md)
8251 {
8252 const Definition *scope = nullptr;
8253 if (md->getGroupDef()) scope = md->getGroupDef();
8254 else if (md->getClassDef()) scope = md->getClassDef();
8255 else if (md->getNamespaceDef()) scope = md->getNamespaceDef();
8256 else if (md->getFileDef()) scope = md->getFileDef();
8257 return scope;
8258 };
8259
8260 auto addMemberToIndices = [addMemberToSearchIndex,getScope](const MemberDef *md)
8261 {
8262 if (md->isLinkableInProject())
8263 {
8264 if (!(md->isEnumerate() && md->isAnonymous()))
8265 {
8266 Doxygen::indexList->addIndexItem(getScope(md),md);
8268 }
8269 if (md->isEnumerate())
8270 {
8271 for (const auto &fmd : md->enumFieldList())
8272 {
8273 Doxygen::indexList->addIndexItem(getScope(fmd),fmd);
8275 }
8276 }
8277 }
8278 };
8279
8280 // for each class member name
8281 for (const auto &mn : *Doxygen::memberNameLinkedMap)
8282 {
8283 // for each member definition
8284 for (const auto &md : *mn)
8285 {
8286 addMemberToIndices(md.get());
8287 }
8288 }
8289 // for each file/namespace function name
8290 for (const auto &mn : *Doxygen::functionNameLinkedMap)
8291 {
8292 // for each member definition
8293 for (const auto &md : *mn)
8294 {
8295 addMemberToIndices(md.get());
8296 }
8297 }
8298}
8299
8300//----------------------------------------------------------------------
8301
8303{
8304 // for each member name
8305 for (const auto &mn : *Doxygen::memberNameLinkedMap)
8306 {
8307 // for each member definition
8308 for (const auto &imd : *mn)
8309 {
8310 MemberDefMutable *md = toMemberDefMutable(imd.get());
8311 if (md)
8312 {
8314 }
8315 }
8316 }
8317 // for each member name
8318 for (const auto &mn : *Doxygen::functionNameLinkedMap)
8319 {
8320 // for each member definition
8321 for (const auto &imd : *mn)
8322 {
8323 MemberDefMutable *md = toMemberDefMutable(imd.get());
8324 if (md)
8325 {
8327 }
8328 }
8329 }
8330}
8331
8332// recursive helper function looking for reimplements/implemented
8333// by relations between class cd and direct or indirect base class bcd
8335{
8336 for (const auto &mn : cd->memberNameInfoLinkedMap()) // for each member in class cd with a unique name
8337 {
8338 for (const auto &imd : *mn) // for each member with a given name
8339 {
8340 MemberDefMutable *md = toMemberDefMutable(imd->memberDef());
8341 if (md && (md->isFunction() || md->isCSharpProperty())) // filter on reimplementable members
8342 {
8343 ClassDef *mbcd = bcd->classDef;
8344 if (mbcd && mbcd->isLinkable()) // filter on linkable classes
8345 {
8346 const auto &bmn = mbcd->memberNameInfoLinkedMap();
8347 const auto &bmni = bmn.find(mn->memberName());
8348 if (bmni) // there are base class members with the same name
8349 {
8350 for (const auto &ibmd : *bmni) // for base class member with that name
8351 {
8352 MemberDefMutable *bmd = toMemberDefMutable(ibmd->memberDef());
8353 if (bmd) // not part of an inline namespace
8354 {
8355 auto lang = bmd->getLanguage();
8356 auto compType = mbcd->compoundType();
8357 if (bmd->virtualness()!=Specifier::Normal ||
8358 lang==SrcLangExt::Python ||
8359 lang==SrcLangExt::Java ||
8360 lang==SrcLangExt::PHP ||
8361 compType==ClassDef::Interface ||
8362 compType==ClassDef::Protocol)
8363 {
8364 const ArgumentList &bmdAl = bmd->argumentList();
8365 const ArgumentList &mdAl = md->argumentList();
8366 //printf(" Base argList='%s'\n Super argList='%s'\n",
8367 // qPrint(argListToString(bmdAl)),
8368 // qPrint(argListToString(mdAl))
8369 // );
8370 if (
8371 lang==SrcLangExt::Python ||
8372 matchArguments2(bmd->getOuterScope(),bmd->getFileDef(),&bmdAl,
8373 md->getOuterScope(), md->getFileDef(), &mdAl,
8374 TRUE,lang
8375 )
8376 )
8377 {
8378 if (lang==SrcLangExt::Python && md->name().startsWith("__")) continue; // private members do not reimplement
8379 //printf("match!\n");
8380 const MemberDef *rmd = md->reimplements();
8381 if (rmd==nullptr) // not already assigned
8382 {
8383 //printf("%s: setting (new) reimplements member %s\n",qPrint(md->qualifiedName()),qPrint(bmd->qualifiedName()));
8384 md->setReimplements(bmd);
8385 }
8386 //printf("%s: add reimplementedBy member %s\n",qPrint(bmd->qualifiedName()),qPrint(md->qualifiedName()));
8387 bmd->insertReimplementedBy(md);
8388 }
8389 else
8390 {
8391 //printf("no match!\n");
8392 }
8393 }
8394 }
8395 }
8396 }
8397 }
8398 }
8399 }
8400 }
8401
8402 // do also for indirect base classes
8403 for (const auto &bbcd : bcd->classDef->baseClasses())
8404 {
8406 }
8407}
8408
8409//----------------------------------------------------------------------
8410// computes the relation between all members. For each member 'm'
8411// the members that override the implementation of 'm' are searched and
8412// the member that 'm' overrides is searched.
8413
8415{
8416 for (const auto &cd : *Doxygen::classLinkedMap)
8417 {
8418 if (cd->isLinkable())
8419 {
8420 for (const auto &bcd : cd->baseClasses())
8421 {
8423 }
8424 }
8425 }
8426}
8427
8428//----------------------------------------------------------------------------
8429
8431{
8432 // for each class
8433 for (const auto &cd : *Doxygen::classLinkedMap)
8434 {
8435 // that is a template
8436 for (const auto &ti : cd->getTemplateInstances())
8437 {
8438 ClassDefMutable *tcdm = toClassDefMutable(ti.classDef);
8439 if (tcdm)
8440 {
8441 tcdm->addMembersToTemplateInstance(cd.get(),cd->templateArguments(),ti.templSpec);
8442 }
8443 }
8444 }
8445}
8446
8447//----------------------------------------------------------------------------
8448
8449static void mergeCategories()
8450{
8451 AUTO_TRACE();
8452 // merge members of categories into the class they extend
8453 for (const auto &cd : *Doxygen::classLinkedMap)
8454 {
8455 int i=cd->name().find('(');
8456 if (i!=-1) // it is an Objective-C category
8457 {
8458 QCString baseName=cd->name().left(i);
8459 ClassDefMutable *baseClass=toClassDefMutable(Doxygen::classLinkedMap->find(baseName));
8460 if (baseClass)
8461 {
8462 AUTO_TRACE_ADD("merging members of category {} into {}",cd->name(),baseClass->name());
8463 baseClass->mergeCategory(cd.get());
8464 }
8465 }
8466 }
8467}
8468
8469// builds the list of all members for each class
8470
8472{
8473 // merge the member list of base classes into the inherited classes.
8474 for (const auto &cd : *Doxygen::classLinkedMap)
8475 {
8476 if (// !cd->isReference() && // not an external class
8477 cd->subClasses().empty() && // is a root of the hierarchy
8478 !cd->baseClasses().empty()) // and has at least one base class
8479 {
8480 ClassDefMutable *cdm = toClassDefMutable(cd.get());
8481 if (cdm)
8482 {
8483 //printf("*** merging members for %s\n",qPrint(cd->name()));
8484 cdm->mergeMembers();
8485 }
8486 }
8487 }
8488 // now sort the member list of all members for all classes.
8489 for (const auto &cd : *Doxygen::classLinkedMap)
8490 {
8491 ClassDefMutable *cdm = toClassDefMutable(cd.get());
8492 if (cdm)
8493 {
8494 cdm->sortAllMembersList();
8495 }
8496 }
8497}
8498
8499//----------------------------------------------------------------------------
8500
8502{
8503 auto processSourceFile = [](FileDef *fd,OutputList &ol,ClangTUParser *parser)
8504 {
8505 bool showSources = fd->generateSourceFile() && !Htags::useHtags; // sources need to be shown in the output
8506 bool parseSources = !fd->isReference() && Doxygen::parseSourcesNeeded; // we needed to parse the sources even if we do not show them
8507 if (showSources)
8508 {
8509 msg("Generating code for file {}...\n",fd->docName());
8510 fd->writeSourceHeader(ol);
8511 fd->writeSourceBody(ol,parser);
8512 fd->writeSourceFooter(ol);
8513 }
8514 else if (parseSources)
8515 {
8516 msg("Parsing code for file {}...\n",fd->docName());
8517 fd->parseSource(parser);
8518 }
8519 };
8520 if (!Doxygen::inputNameLinkedMap->empty())
8521 {
8522#if USE_LIBCLANG
8524 {
8525 StringUnorderedSet processedFiles;
8526
8527 // create a dictionary with files to process
8528 StringUnorderedSet filesToProcess;
8529
8530 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8531 {
8532 for (const auto &fd : *fn)
8533 {
8534 filesToProcess.insert(fd->absFilePath().str());
8535 }
8536 }
8537 // process source files (and their include dependencies)
8538 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8539 {
8540 for (const auto &fd : *fn)
8541 {
8542 if (fd->isSource() && !fd->isReference() && fd->getLanguage()==SrcLangExt::Cpp &&
8543 (fd->generateSourceFile() ||
8545 )
8546 )
8547 {
8548 auto clangParser = ClangParser::instance()->createTUParser(fd.get());
8549 clangParser->parse();
8550 processSourceFile(fd.get(),*g_outputList,clangParser.get());
8551
8552 for (auto incFile : clangParser->filesInSameTU())
8553 {
8554 if (filesToProcess.find(incFile)!=filesToProcess.end() && // part of input
8555 fd->absFilePath()!=QCString(incFile) && // not same file
8556 processedFiles.find(incFile)==processedFiles.end()) // not yet marked as processed
8557 {
8558 StringVector moreFiles;
8559 bool ambig = false;
8560 FileDef *ifd=findFileDef(Doxygen::inputNameLinkedMap,incFile.c_str(),ambig);
8561 if (ifd && !ifd->isReference())
8562 {
8563 processSourceFile(ifd,*g_outputList,clangParser.get());
8564 processedFiles.insert(incFile);
8565 }
8566 }
8567 }
8568 processedFiles.insert(fd->absFilePath().str());
8569 }
8570 }
8571 }
8572 // process remaining files
8573 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8574 {
8575 for (const auto &fd : *fn)
8576 {
8577 if (processedFiles.find(fd->absFilePath().str())==processedFiles.end()) // not yet processed
8578 {
8579 if (fd->getLanguage()==SrcLangExt::Cpp) // C/C++ file, use clang parser
8580 {
8581 auto clangParser = ClangParser::instance()->createTUParser(fd.get());
8582 clangParser->parse();
8583 processSourceFile(fd.get(),*g_outputList,clangParser.get());
8584 }
8585 else // non C/C++ file, use built-in parser
8586 {
8587 processSourceFile(fd.get(),*g_outputList,nullptr);
8588 }
8589 }
8590 }
8591 }
8592 }
8593 else
8594#endif
8595 {
8596 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
8597 if (numThreads>1)
8598 {
8599 msg("Generating code files using {} threads.\n",numThreads);
8600 struct SourceContext
8601 {
8602 SourceContext(FileDef *fd_,bool gen_,const OutputList &ol_)
8603 : fd(fd_), generateSourceFile(gen_), ol(ol_) {}
8604 FileDef *fd;
8605 bool generateSourceFile;
8606 OutputList ol;
8607 };
8608 ThreadPool threadPool(numThreads);
8609 std::vector< std::future< std::shared_ptr<SourceContext> > > results;
8610 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8611 {
8612 for (const auto &fd : *fn)
8613 {
8614 bool generateSourceFile = fd->generateSourceFile() && !Htags::useHtags;
8615 auto ctx = std::make_shared<SourceContext>(fd.get(),generateSourceFile,*g_outputList);
8616 auto processFile = [ctx]()
8617 {
8618 if (ctx->generateSourceFile)
8619 {
8620 msg("Generating code for file {}...\n",ctx->fd->docName());
8621 }
8622 else
8623 {
8624 msg("Parsing code for file {}...\n",ctx->fd->docName());
8625 }
8626 StringVector filesInSameTu;
8627 ctx->fd->getAllIncludeFilesRecursively(filesInSameTu);
8628 if (ctx->generateSourceFile) // sources need to be shown in the output
8629 {
8630 ctx->fd->writeSourceHeader(ctx->ol);
8631 ctx->fd->writeSourceBody(ctx->ol,nullptr);
8632 ctx->fd->writeSourceFooter(ctx->ol);
8633 }
8634 else if (!ctx->fd->isReference() && Doxygen::parseSourcesNeeded)
8635 // we needed to parse the sources even if we do not show them
8636 {
8637 ctx->fd->parseSource(nullptr);
8638 }
8639 return ctx;
8640 };
8641 results.emplace_back(threadPool.queue(processFile));
8642 }
8643 }
8644 for (auto &f : results)
8645 {
8646 auto ctx = f.get();
8647 }
8648 }
8649 else // single threaded version
8650 {
8651 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8652 {
8653 for (const auto &fd : *fn)
8654 {
8655 StringVector filesInSameTu;
8656 fd->getAllIncludeFilesRecursively(filesInSameTu);
8657 processSourceFile(fd.get(),*g_outputList,nullptr);
8658 }
8659 }
8660 }
8661 }
8662 }
8663}
8664
8665//----------------------------------------------------------------------------
8666
8667static void generateFileDocs()
8668{
8669 if (Index::instance().numDocumentedFiles()==0) return;
8670
8671 if (!Doxygen::inputNameLinkedMap->empty())
8672 {
8673 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
8674 if (numThreads>1) // multi threaded processing
8675 {
8676 struct DocContext
8677 {
8678 DocContext(FileDef *fd_,const OutputList &ol_)
8679 : fd(fd_), ol(ol_) {}
8680 FileDef *fd;
8681 OutputList ol;
8682 };
8683 ThreadPool threadPool(numThreads);
8684 std::vector< std::future< std::shared_ptr<DocContext> > > results;
8685 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8686 {
8687 for (const auto &fd : *fn)
8688 {
8689 bool doc = fd->isLinkableInProject();
8690 if (doc)
8691 {
8692 auto ctx = std::make_shared<DocContext>(fd.get(),*g_outputList);
8693 auto processFile = [ctx]() {
8694 msg("Generating docs for file {}...\n",ctx->fd->docName());
8695 ctx->fd->writeDocumentation(ctx->ol);
8696 return ctx;
8697 };
8698 results.emplace_back(threadPool.queue(processFile));
8699 }
8700 }
8701 }
8702 for (auto &f : results)
8703 {
8704 auto ctx = f.get();
8705 }
8706 }
8707 else // single threaded processing
8708 {
8709 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8710 {
8711 for (const auto &fd : *fn)
8712 {
8713 bool doc = fd->isLinkableInProject();
8714 if (doc)
8715 {
8716 msg("Generating docs for file {}...\n",fd->docName());
8717 fd->writeDocumentation(*g_outputList);
8718 }
8719 }
8720 }
8721 }
8722 }
8723}
8724
8725//----------------------------------------------------------------------------
8726
8728{
8729 // add source references for class definitions
8730 for (const auto &cd : *Doxygen::classLinkedMap)
8731 {
8732 const FileDef *fd=cd->getBodyDef();
8733 if (fd && cd->isLinkableInProject() && cd->getStartDefLine()!=-1)
8734 {
8735 const_cast<FileDef*>(fd)->addSourceRef(cd->getStartDefLine(),cd.get(),nullptr);
8736 }
8737 }
8738 // add source references for concept definitions
8739 for (const auto &cd : *Doxygen::conceptLinkedMap)
8740 {
8741 const FileDef *fd=cd->getBodyDef();
8742 if (fd && cd->isLinkableInProject() && cd->getStartDefLine()!=-1)
8743 {
8744 const_cast<FileDef*>(fd)->addSourceRef(cd->getStartDefLine(),cd.get(),nullptr);
8745 }
8746 }
8747 // add source references for namespace definitions
8748 for (const auto &nd : *Doxygen::namespaceLinkedMap)
8749 {
8750 const FileDef *fd=nd->getBodyDef();
8751 if (fd && nd->isLinkableInProject() && nd->getStartDefLine()!=-1)
8752 {
8753 const_cast<FileDef*>(fd)->addSourceRef(nd->getStartDefLine(),nd.get(),nullptr);
8754 }
8755 }
8756
8757 // add source references for member names
8758 for (const auto &mn : *Doxygen::memberNameLinkedMap)
8759 {
8760 for (const auto &md : *mn)
8761 {
8762 //printf("class member %s: def=%s body=%d link?=%d\n",
8763 // qPrint(md->name()),
8764 // md->getBodyDef()?qPrint(md->getBodyDef()->name()):"<none>",
8765 // md->getStartBodyLine(),md->isLinkableInProject());
8766 const FileDef *fd=md->getBodyDef();
8767 if (fd &&
8768 md->getStartDefLine()!=-1 &&
8769 md->isLinkableInProject() &&
8771 )
8772 {
8773 //printf("Found member '%s' in file '%s' at line '%d' def=%s\n",
8774 // qPrint(md->name()),qPrint(fd->name()),md->getStartBodyLine(),qPrint(md->getOuterScope()->name()));
8775 const_cast<FileDef*>(fd)->addSourceRef(md->getStartDefLine(),md->getOuterScope(),md.get());
8776 }
8777 }
8778 }
8779 for (const auto &mn : *Doxygen::functionNameLinkedMap)
8780 {
8781 for (const auto &md : *mn)
8782 {
8783 const FileDef *fd=md->getBodyDef();
8784 //printf("member %s body=[%d,%d] fd=%p link=%d parseSources=%d\n",
8785 // qPrint(md->name()),
8786 // md->getStartBodyLine(),md->getEndBodyLine(),fd,
8787 // md->isLinkableInProject(),
8788 // Doxygen::parseSourcesNeeded);
8789 if (fd &&
8790 md->getStartDefLine()!=-1 &&
8791 md->isLinkableInProject() &&
8793 )
8794 {
8795 //printf("Found member '%s' in file '%s' at line '%d' def=%s\n",
8796 // qPrint(md->name()),qPrint(fd->name()),md->getStartBodyLine(),qPrint(md->getOuterScope()->name()));
8797 const_cast<FileDef*>(fd)->addSourceRef(md->getStartDefLine(),md->getOuterScope(),md.get());
8798 }
8799 }
8800 }
8801}
8802
8803//----------------------------------------------------------------------------
8804
8805// add the macro definitions found during preprocessing as file members
8806static void buildDefineList()
8807{
8808 AUTO_TRACE();
8809 for (const auto &s : g_inputFiles)
8810 {
8811 auto it = Doxygen::macroDefinitions.find(s);
8813 {
8814 for (const auto &def : it->second)
8815 {
8816 auto md = createMemberDef(
8817 def.fileName,def.lineNr,def.columnNr,
8818 "#define",def.name,def.args,QCString(),
8819 Protection::Public,Specifier::Normal,FALSE,Relationship::Member,MemberType::Define,
8820 ArgumentList(),ArgumentList(),"");
8821 auto mmd = toMemberDefMutable(md.get());
8822
8823 if (!def.args.isEmpty())
8824 {
8825 mmd->moveArgumentList(stringToArgumentList(SrcLangExt::Cpp, def.args));
8826 }
8827 mmd->setInitializer(def.definition);
8828 mmd->setFileDef(def.fileDef);
8829 mmd->setDefinition("#define "+def.name);
8830
8831 MemberName *mn=Doxygen::functionNameLinkedMap->add(def.name);
8832 if (def.fileDef)
8833 {
8834 const MemberList *defMl = def.fileDef->getMemberList(MemberListType::DocDefineMembers());
8835 if (defMl)
8836 {
8837 const MemberDef *defMd = defMl->findRev(def.name);
8838 if (defMd) // definition already stored
8839 {
8840 mmd->setRedefineCount(defMd->redefineCount()+1);
8841 }
8842 }
8843 def.fileDef->insertMember(md.get());
8844 }
8845 AUTO_TRACE_ADD("adding macro {} with definition {}",def.name,def.definition);
8846 mn->push_back(std::move(md));
8847 }
8848 }
8849 }
8850}
8851
8852//----------------------------------------------------------------------------
8853
8854static void sortMemberLists()
8855{
8856 // sort class member lists
8857 for (const auto &cd : *Doxygen::classLinkedMap)
8858 {
8859 ClassDefMutable *cdm = toClassDefMutable(cd.get());
8860 if (cdm)
8861 {
8862 cdm->sortMemberLists();
8863 }
8864 }
8865
8866 // sort namespace member lists
8867 for (const auto &nd : *Doxygen::namespaceLinkedMap)
8868 {
8870 if (ndm)
8871 {
8872 ndm->sortMemberLists();
8873 }
8874 }
8875
8876 // sort file member lists
8877 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8878 {
8879 for (const auto &fd : *fn)
8880 {
8881 fd->sortMemberLists();
8882 }
8883 }
8884
8885 // sort group member lists
8886 for (const auto &gd : *Doxygen::groupLinkedMap)
8887 {
8888 gd->sortMemberLists();
8889 }
8890
8892}
8893
8894//----------------------------------------------------------------------------
8895
8896static bool isSymbolHidden(const Definition *d)
8897{
8898 bool hidden = d->isHidden();
8899 const Definition *parent = d->getOuterScope();
8900 return parent ? hidden || isSymbolHidden(parent) : hidden;
8901}
8902
8904{
8905 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
8906 if (numThreads>1)
8907 {
8908 ThreadPool threadPool(numThreads);
8909 std::vector < std::future< void > > results;
8910 // queue the work
8911 for (const auto &[name,symList] : *Doxygen::symbolMap)
8912 {
8913 for (const auto &def : symList)
8914 {
8916 if (dm && !isSymbolHidden(def) && !def->isArtificial() && def->isLinkableInProject())
8917 {
8918 auto processTooltip = [dm]() {
8919 dm->computeTooltip();
8920 };
8921 results.emplace_back(threadPool.queue(processTooltip));
8922 }
8923 }
8924 }
8925 // wait for the results
8926 for (auto &f : results)
8927 {
8928 f.get();
8929 }
8930 }
8931 else
8932 {
8933 for (const auto &[name,symList] : *Doxygen::symbolMap)
8934 {
8935 for (const auto &def : symList)
8936 {
8938 if (dm && !isSymbolHidden(def) && !def->isArtificial() && def->isLinkableInProject())
8939 {
8940 dm->computeTooltip();
8941 }
8942 }
8943 }
8944 }
8945}
8946
8947//----------------------------------------------------------------------------
8948
8950{
8951 for (const auto &cd : *Doxygen::classLinkedMap)
8952 {
8953 ClassDefMutable *cdm = toClassDefMutable(cd.get());
8954 if (cdm)
8955 {
8956 cdm->setAnonymousEnumType();
8957 }
8958 }
8959}
8960
8961//----------------------------------------------------------------------------
8962
8963static void countMembers()
8964{
8965 for (const auto &cd : *Doxygen::classLinkedMap)
8966 {
8967 ClassDefMutable *cdm = toClassDefMutable(cd.get());
8968 if (cdm)
8969 {
8970 cdm->countMembers();
8971 }
8972 }
8973
8974 for (const auto &nd : *Doxygen::namespaceLinkedMap)
8975 {
8977 if (ndm)
8978 {
8979 ndm->countMembers();
8980 }
8981 }
8982
8983 for (const auto &fn : *Doxygen::inputNameLinkedMap)
8984 {
8985 for (const auto &fd : *fn)
8986 {
8987 fd->countMembers();
8988 }
8989 }
8990
8991 for (const auto &gd : *Doxygen::groupLinkedMap)
8992 {
8993 gd->countMembers();
8994 }
8995
8996 auto &mm = ModuleManager::instance();
8997 mm.countMembers();
8998}
8999
9000
9001//----------------------------------------------------------------------------
9002// generate the documentation for all classes
9003
9004static void generateDocsForClassList(const std::vector<ClassDefMutable*> &classList)
9005{
9006 AUTO_TRACE();
9007 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
9008 if (numThreads>1) // multi threaded processing
9009 {
9010 struct DocContext
9011 {
9012 DocContext(ClassDefMutable *cd_,const OutputList &ol_)
9013 : cd(cd_), ol(ol_) {}
9014 ClassDefMutable *cd;
9015 OutputList ol;
9016 };
9017 ThreadPool threadPool(numThreads);
9018 std::vector< std::future< std::shared_ptr<DocContext> > > results;
9019 for (const auto &cd : classList)
9020 {
9021 //printf("cd=%s getOuterScope=%p global=%p\n",qPrint(cd->name()),cd->getOuterScope(),Doxygen::globalScope);
9022 if (cd->getOuterScope()==nullptr || // <-- should not happen, but can if we read an old tag file
9023 cd->getOuterScope()==Doxygen::globalScope // only look at global classes
9024 )
9025 {
9026 auto ctx = std::make_shared<DocContext>(cd,*g_outputList);
9027 auto processFile = [ctx]()
9028 {
9029 msg("Generating docs for compound {}...\n",ctx->cd->displayName());
9030
9031 // skip external references, anonymous compounds and
9032 // template instances
9033 if (!ctx->cd->isHidden() && !ctx->cd->isEmbeddedInOuterScope() &&
9034 ctx->cd->isLinkableInProject() && !ctx->cd->isImplicitTemplateInstance())
9035 {
9036 ctx->cd->writeDocumentation(ctx->ol);
9037 ctx->cd->writeMemberList(ctx->ol);
9038 }
9039
9040 // even for undocumented classes, the inner classes can be documented.
9041 ctx->cd->writeDocumentationForInnerClasses(ctx->ol);
9042 return ctx;
9043 };
9044 results.emplace_back(threadPool.queue(processFile));
9045 }
9046 }
9047 for (auto &f : results)
9048 {
9049 auto ctx = f.get();
9050 }
9051 }
9052 else // single threaded processing
9053 {
9054 for (const auto &cd : classList)
9055 {
9056 //printf("cd=%s getOuterScope=%p global=%p hidden=%d embeddedInOuterScope=%d\n",
9057 // qPrint(cd->name()),cd->getOuterScope(),Doxygen::globalScope,cd->isHidden(),cd->isEmbeddedInOuterScope());
9058 if (cd->getOuterScope()==nullptr || // <-- should not happen, but can if we read an old tag file
9059 cd->getOuterScope()==Doxygen::globalScope // only look at global classes
9060 )
9061 {
9062 // skip external references, anonymous compounds and
9063 // template instances
9064 if ( !cd->isHidden() && !cd->isEmbeddedInOuterScope() &&
9065 cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
9066 {
9067 msg("Generating docs for compound {}...\n",cd->displayName());
9068
9069 cd->writeDocumentation(*g_outputList);
9070 cd->writeMemberList(*g_outputList);
9071 }
9072 // even for undocumented classes, the inner classes can be documented.
9073 cd->writeDocumentationForInnerClasses(*g_outputList);
9074 }
9075 }
9076 }
9077}
9078
9079static void addClassAndNestedClasses(std::vector<ClassDefMutable*> &list,ClassDefMutable *cd)
9080{
9081 list.push_back(cd);
9082 for (const auto &innerCdi : cd->getClasses())
9083 {
9084 ClassDefMutable *innerCd = toClassDefMutable(innerCdi);
9085 if (innerCd)
9086 {
9087 AUTO_TRACE("innerCd={} isLinkable={} isImplicitTemplateInstance={} protectLevelVisible={} embeddedInOuterScope={}",
9088 innerCd->name(),innerCd->isLinkableInProject(),innerCd->isImplicitTemplateInstance(),protectionLevelVisible(innerCd->protection()),
9089 innerCd->isEmbeddedInOuterScope());
9090 }
9091 if (innerCd && innerCd->isLinkableInProject() && !innerCd->isImplicitTemplateInstance() &&
9092 protectionLevelVisible(innerCd->protection()) &&
9093 !innerCd->isEmbeddedInOuterScope()
9094 )
9095 {
9096 list.push_back(innerCd);
9097 addClassAndNestedClasses(list,innerCd);
9098 }
9099 }
9100}
9101
9103{
9104 std::vector<ClassDefMutable*> classList;
9105 for (const auto &cdi : *Doxygen::classLinkedMap)
9106 {
9107 ClassDefMutable *cd = toClassDefMutable(cdi.get());
9108 if (cd && (cd->getOuterScope()==nullptr ||
9110 {
9111 addClassAndNestedClasses(classList,cd);
9112 }
9113 }
9114 for (const auto &cdi : *Doxygen::hiddenClassLinkedMap)
9115 {
9116 ClassDefMutable *cd = toClassDefMutable(cdi.get());
9117 if (cd && (cd->getOuterScope()==nullptr ||
9119 {
9120 addClassAndNestedClasses(classList,cd);
9121 }
9122 }
9123 generateDocsForClassList(classList);
9124}
9125
9126//----------------------------------------------------------------------------
9127
9129{
9130 for (const auto &cdi : *Doxygen::conceptLinkedMap)
9131 {
9133
9134 //printf("cd=%s getOuterScope=%p global=%p\n",qPrint(cd->name()),cd->getOuterScope(),Doxygen::globalScope);
9135 if (cd &&
9136 (cd->getOuterScope()==nullptr || // <-- should not happen, but can if we read an old tag file
9137 cd->getOuterScope()==Doxygen::globalScope // only look at global concepts
9138 ) && !cd->isHidden() && cd->isLinkableInProject()
9139 )
9140 {
9141 msg("Generating docs for concept {}...\n",cd->displayName());
9143 }
9144 }
9145}
9146
9147//----------------------------------------------------------------------------
9148
9150{
9151 for (const auto &mn : *Doxygen::memberNameLinkedMap)
9152 {
9153 for (const auto &imd : *mn)
9154 {
9155 MemberDefMutable *md = toMemberDefMutable(imd.get());
9156 //static int count=0;
9157 //printf("%04d Member '%s'\n",count++,qPrint(md->qualifiedName()));
9158 if (md && md->documentation().isEmpty() && md->briefDescription().isEmpty())
9159 { // no documentation yet
9160 const MemberDef *bmd = md->reimplements();
9161 while (bmd && bmd->documentation().isEmpty() &&
9162 bmd->briefDescription().isEmpty()
9163 )
9164 { // search up the inheritance tree for a documentation member
9165 //printf("bmd=%s class=%s\n",qPrint(bmd->name()),qPrint(bmd->getClassDef()->name()));
9166 bmd = bmd->reimplements();
9167 }
9168 if (bmd) // copy the documentation from the reimplemented member
9169 {
9170 md->setInheritsDocsFrom(bmd);
9171 md->setDocumentation(bmd->documentation(),bmd->docFile(),bmd->docLine());
9173 md->setBriefDescription(bmd->briefDescription(),bmd->briefFile(),bmd->briefLine());
9174 md->copyArgumentNames(bmd);
9176 }
9177 }
9178 }
9179 }
9180}
9181
9182//----------------------------------------------------------------------------
9183
9185{
9186 // for each file
9187 for (const auto &fn : *Doxygen::inputNameLinkedMap)
9188 {
9189 for (const auto &fd : *fn)
9190 {
9191 fd->combineUsingRelations();
9192 }
9193 }
9194
9195 // for each namespace
9196 NamespaceDefSet visitedNamespaces;
9197 for (const auto &nd : *Doxygen::namespaceLinkedMap)
9198 {
9200 if (ndm)
9201 {
9202 ndm->combineUsingRelations(visitedNamespaces);
9203 }
9204 }
9205}
9206
9207//----------------------------------------------------------------------------
9208
9210{
9211 // for each class
9212 for (const auto &cd : *Doxygen::classLinkedMap)
9213 {
9214 ClassDefMutable *cdm = toClassDefMutable(cd.get());
9215 if (cdm)
9216 {
9218 }
9219 }
9220 // for each file
9221 for (const auto &fn : *Doxygen::inputNameLinkedMap)
9222 {
9223 for (const auto &fd : *fn)
9224 {
9225 fd->addMembersToMemberGroup();
9226 }
9227 }
9228 // for each namespace
9229 for (const auto &nd : *Doxygen::namespaceLinkedMap)
9230 {
9232 if (ndm)
9233 {
9235 }
9236 }
9237 // for each group
9238 for (const auto &gd : *Doxygen::groupLinkedMap)
9239 {
9240 gd->addMembersToMemberGroup();
9241 }
9243}
9244
9245//----------------------------------------------------------------------------
9246
9248{
9249 // for each class
9250 for (const auto &cd : *Doxygen::classLinkedMap)
9251 {
9252 ClassDefMutable *cdm = toClassDefMutable(cd.get());
9253 if (cdm)
9254 {
9256 }
9257 }
9258 // for each file
9259 for (const auto &fn : *Doxygen::inputNameLinkedMap)
9260 {
9261 for (const auto &fd : *fn)
9262 {
9263 fd->distributeMemberGroupDocumentation();
9264 }
9265 }
9266 // for each namespace
9267 for (const auto &nd : *Doxygen::namespaceLinkedMap)
9268 {
9270 if (ndm)
9271 {
9273 }
9274 }
9275 // for each group
9276 for (const auto &gd : *Doxygen::groupLinkedMap)
9277 {
9278 gd->distributeMemberGroupDocumentation();
9279 }
9281}
9282
9283//----------------------------------------------------------------------------
9284
9286{
9287 // for each class
9288 for (const auto &cd : *Doxygen::classLinkedMap)
9289 {
9290 ClassDefMutable *cdm = toClassDefMutable(cd.get());
9291 if (cdm)
9292 {
9294 }
9295 }
9296 // for each concept
9297 for (const auto &cd : *Doxygen::conceptLinkedMap)
9298 {
9299 ConceptDefMutable *cdm = toConceptDefMutable(cd.get());
9300 if (cdm)
9301 {
9303 }
9304 }
9305 // for each file
9306 for (const auto &fn : *Doxygen::inputNameLinkedMap)
9307 {
9308 for (const auto &fd : *fn)
9309 {
9310 fd->findSectionsInDocumentation();
9311 }
9312 }
9313 // for each namespace
9314 for (const auto &nd : *Doxygen::namespaceLinkedMap)
9315 {
9317 if (ndm)
9318 {
9320 }
9321 }
9322 // for each group
9323 for (const auto &gd : *Doxygen::groupLinkedMap)
9324 {
9325 gd->findSectionsInDocumentation();
9326 }
9327 // for each page
9328 for (const auto &pd : *Doxygen::pageLinkedMap)
9329 {
9330 pd->findSectionsInDocumentation();
9331 }
9332 // for each directory
9333 for (const auto &dd : *Doxygen::dirLinkedMap)
9334 {
9335 dd->findSectionsInDocumentation();
9336 }
9338 if (Doxygen::mainPage) Doxygen::mainPage->findSectionsInDocumentation();
9339}
9340
9341//----------------------------------------------------------------------
9342
9343
9345{
9346 // remove all references to classes from the cache
9347 // as there can be new template instances in the inheritance path
9348 // to this class. Optimization: only remove those classes that
9349 // have inheritance instances as direct or indirect sub classes.
9350 StringVector elementsToRemove;
9351 for (const auto &ci : *Doxygen::typeLookupCache)
9352 {
9353 const LookupInfo &li = ci.second;
9354 if (li.definition)
9355 {
9356 elementsToRemove.push_back(ci.first);
9357 }
9358 }
9359 for (const auto &k : elementsToRemove)
9360 {
9361 Doxygen::typeLookupCache->remove(k);
9362 }
9363
9364 // remove all cached typedef resolutions whose target is a
9365 // template class as this may now be a template instance
9366 // for each global function name
9367 for (const auto &fn : *Doxygen::functionNameLinkedMap)
9368 {
9369 // for each function with that name
9370 for (const auto &ifmd : *fn)
9371 {
9372 MemberDefMutable *fmd = toMemberDefMutable(ifmd.get());
9373 if (fmd && fmd->isTypedefValCached())
9374 {
9375 const ClassDef *cd = fmd->getCachedTypedefVal();
9376 if (cd->isTemplate()) fmd->invalidateTypedefValCache();
9377 }
9378 }
9379 }
9380 // for each class method name
9381 for (const auto &nm : *Doxygen::memberNameLinkedMap)
9382 {
9383 // for each function with that name
9384 for (const auto &imd : *nm)
9385 {
9386 MemberDefMutable *md = toMemberDefMutable(imd.get());
9387 if (md && md->isTypedefValCached())
9388 {
9389 const ClassDef *cd = md->getCachedTypedefVal();
9390 if (cd->isTemplate()) md->invalidateTypedefValCache();
9391 }
9392 }
9393 }
9394}
9395
9396//----------------------------------------------------------------------------
9397
9399{
9400 // Remove all unresolved references to classes from the cache.
9401 // This is needed before resolving the inheritance relations, since
9402 // it would otherwise not find the inheritance relation
9403 // for C in the example below, as B::I was already found to be unresolvable
9404 // (which is correct if you ignore the inheritance relation between A and B).
9405 //
9406 // class A { class I {} };
9407 // class B : public A {};
9408 // class C : public B::I {};
9409
9410 StringVector elementsToRemove;
9411 for (const auto &ci : *Doxygen::typeLookupCache)
9412 {
9413 const LookupInfo &li = ci.second;
9414 if (li.definition==nullptr && li.typeDef==nullptr)
9415 {
9416 elementsToRemove.push_back(ci.first);
9417 }
9418 }
9419 for (const auto &k : elementsToRemove)
9420 {
9421 Doxygen::typeLookupCache->remove(k);
9422 }
9423
9424 // for each global function name
9425 for (const auto &fn : *Doxygen::functionNameLinkedMap)
9426 {
9427 // for each function with that name
9428 for (const auto &ifmd : *fn)
9429 {
9430 MemberDefMutable *fmd = toMemberDefMutable(ifmd.get());
9431 if (fmd)
9432 {
9434 }
9435 }
9436 }
9437 // for each class method name
9438 for (const auto &nm : *Doxygen::memberNameLinkedMap)
9439 {
9440 // for each function with that name
9441 for (const auto &imd : *nm)
9442 {
9443 MemberDefMutable *md = toMemberDefMutable(imd.get());
9444 if (md)
9445 {
9447 }
9448 }
9449 }
9450
9451}
9452
9453//----------------------------------------------------------------------------
9454// Returns TRUE if the entry and member definition have equal file names,
9455// otherwise FALSE.
9456
9457static bool haveEqualFileNames(const Entry *root,const MemberDef *md)
9458{
9459 const FileDef *fd = md->getFileDef();
9460 if (!fd)
9461 {
9462 return FALSE;
9463 }
9464
9465 return fd->absFilePath() == root->fileName;
9466}
9467
9468//----------------------------------------------------------------------------
9469
9470static void addDefineDoc(const Entry *root, MemberDefMutable *md)
9471{
9472 md->setDocumentation(root->doc,root->docFile,root->docLine);
9473 md->setDocsForDefinition(!root->proto);
9474 md->setBriefDescription(root->brief,root->briefFile,root->briefLine);
9475 if (md->inbodyDocumentation().isEmpty())
9476 {
9478 }
9479 if (md->getStartBodyLine()==-1 && root->bodyLine!=-1)
9480 {
9481 md->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
9482 md->setBodyDef(root->fileDef());
9483 }
9485 md->setMaxInitLines(root->initLines);
9487 md->setRefItems(root->sli);
9488 if (root->mGrpId!=-1) md->setMemberGroupId(root->mGrpId);
9489 addMemberToGroups(root,md);
9491}
9492
9493//----------------------------------------------------------------------------
9494
9496{
9497 if ((root->section.isDefineDoc() || root->section.isDefine()) && !root->name.isEmpty())
9498 {
9499 //printf("found define '%s' '%s' brief='%s' doc='%s'\n",
9500 // qPrint(root->name),qPrint(root->args),qPrint(root->brief),qPrint(root->doc));
9501
9502 if (root->tagInfo() && !root->name.isEmpty()) // define read from a tag file
9503 {
9504 auto md = createMemberDef(root->tagInfo()->tagName,1,1,
9505 "#define",root->name,root->args,QCString(),
9506 Protection::Public,Specifier::Normal,FALSE,Relationship::Member,MemberType::Define,
9507 ArgumentList(),ArgumentList(),"");
9508 auto mmd = toMemberDefMutable(md.get());
9509 mmd->setTagInfo(root->tagInfo());
9510 mmd->setLanguage(root->lang);
9511 //printf("Searching for '%s' fd=%p\n",qPrint(filePathName),fd);
9512 mmd->setFileDef(root->parent()->fileDef());
9513 //printf("Adding member=%s\n",qPrint(md->name()));
9515 mn->push_back(std::move(md));
9516 }
9518 if (mn)
9519 {
9520 int count=0;
9521 for (const auto &md : *mn)
9522 {
9523 if (md->memberType()==MemberType::Define) count++;
9524 }
9525 if (count==1)
9526 {
9527 for (const auto &imd : *mn)
9528 {
9529 MemberDefMutable *md = toMemberDefMutable(imd.get());
9530 if (md && md->memberType()==MemberType::Define)
9531 {
9532 addDefineDoc(root,md);
9533 }
9534 }
9535 }
9536 else if (count>1 &&
9537 (!root->doc.isEmpty() ||
9538 !root->brief.isEmpty() ||
9539 root->bodyLine!=-1
9540 )
9541 )
9542 // multiple defines don't know where to add docs
9543 // but maybe they are in different files together with their documentation
9544 {
9545 for (const auto &imd : *mn)
9546 {
9547 MemberDefMutable *md = toMemberDefMutable(imd.get());
9548 if (md && md->memberType()==MemberType::Define)
9549 {
9550 if (haveEqualFileNames(root, md) || isEntryInGroupOfMember(root, md))
9551 // doc and define in the same file or group assume they belong together.
9552 {
9553 addDefineDoc(root,md);
9554 }
9555 }
9556 }
9557 //warn("define {} found in the following files:\n",root->name);
9558 //warn("Cannot determine where to add the documentation found "
9559 // "at line {} of file {}. \n",
9560 // root->startLine,root->fileName);
9561 }
9562 }
9563 else if (!root->doc.isEmpty() || !root->brief.isEmpty()) // define not found
9564 {
9565 bool preEnabled = Config_getBool(ENABLE_PREPROCESSING);
9566 if (preEnabled)
9567 {
9568 warn(root->fileName,root->startLine,"documentation for unknown define {} found.",root->name);
9569 }
9570 else
9571 {
9572 warn(root->fileName,root->startLine, "found documented #define {} but ignoring it because ENABLE_PREPROCESSING is NO.", root->name);
9573 }
9574 }
9575 }
9576 for (const auto &e : root->children()) findDefineDocumentation(e.get());
9577}
9578
9579//----------------------------------------------------------------------------
9580
9581static void findDirDocumentation(const Entry *root)
9582{
9583 if (root->section.isDirDoc())
9584 {
9585 QCString normalizedName = root->name;
9586 normalizedName = substitute(normalizedName,"\\","/");
9587 //printf("root->docFile=%s normalizedName=%s\n",
9588 // qPrint(root->docFile),qPrint(normalizedName));
9589 if (root->docFile==normalizedName) // current dir?
9590 {
9591 int lastSlashPos=normalizedName.findRev('/');
9592 if (lastSlashPos!=-1) // strip file name
9593 {
9594 normalizedName=normalizedName.left(lastSlashPos);
9595 }
9596 }
9597 if (normalizedName.at(normalizedName.length()-1)!='/')
9598 {
9599 normalizedName+='/';
9600 }
9601 DirDef *matchingDir=nullptr;
9602 for (const auto &dir : *Doxygen::dirLinkedMap)
9603 {
9604 //printf("Dir: %s<->%s\n",qPrint(dir->name()),qPrint(normalizedName));
9605 if (dir->name().right(normalizedName.length())==normalizedName)
9606 {
9607 if (matchingDir)
9608 {
9609 warn(root->fileName,root->startLine,
9610 "\\dir command matches multiple directories.\n"
9611 " Applying the command for directory {}\n"
9612 " Ignoring the command for directory {}",
9613 matchingDir->name(),dir->name()
9614 );
9615 }
9616 else
9617 {
9618 matchingDir=dir.get();
9619 }
9620 }
9621 }
9622 if (matchingDir)
9623 {
9624 //printf("Match for with dir %s #anchor=%zu\n",qPrint(matchingDir->name()),root->anchors.size());
9625 matchingDir->setBriefDescription(root->brief,root->briefFile,root->briefLine);
9626 matchingDir->setDocumentation(root->doc,root->docFile,root->docLine);
9627 matchingDir->setRefItems(root->sli);
9628 matchingDir->addSectionsToDefinition(root->anchors);
9629 root->commandOverrides.apply_directoryGraph([&](bool b) { matchingDir->overrideDirectoryGraph(b); });
9630 addDirToGroups(root,matchingDir);
9631 }
9632 else
9633 {
9634 warn(root->fileName,root->startLine,"No matching directory found for command \\dir {}",normalizedName);
9635 }
9636 }
9637 for (const auto &e : root->children()) findDirDocumentation(e.get());
9638}
9639
9640
9641//----------------------------------------------------------------------------
9642// create a (sorted) list of separate documentation pages
9643
9644static void buildPageList(Entry *root)
9645{
9646 if (root->section.isPageDoc())
9647 {
9648 if (!root->name.isEmpty())
9649 {
9650 addRelatedPage(root);
9651 }
9652 }
9653 else if (root->section.isMainpageDoc())
9654 {
9655 QCString title=root->args.stripWhiteSpace();
9656 if (title.isEmpty()) title=theTranslator->trMainPage();
9657 //QCString name = Config_getBool(GENERATE_TREEVIEW)?"main":"index";
9658 QCString name = "index";
9659 addRefItem(root->sli,
9660 name,
9661 "page",
9662 name,
9663 title,
9664 QCString(),nullptr
9665 );
9666 }
9667 for (const auto &e : root->children()) buildPageList(e.get());
9668}
9669
9670// search for the main page defined in this project
9671static void findMainPage(Entry *root)
9672{
9673 if (root->section.isMainpageDoc())
9674 {
9675 if (Doxygen::mainPage==nullptr && root->tagInfo()==nullptr)
9676 {
9677 //printf("mainpage: docLine=%d startLine=%d\n",root->docLine,root->startLine);
9678 //printf("Found main page! \n======\n%s\n=======\n",qPrint(root->doc));
9679 QCString title=root->args.stripWhiteSpace();
9680 if (title.isEmpty()) title = Config_getString(PROJECT_NAME);
9681 //QCString indexName=Config_getBool(GENERATE_TREEVIEW)?"main":"index";
9682 QCString indexName="index";
9684 indexName, root->brief+root->doc+root->inbodyDocs,title);
9685 //setFileNameForSections(root->anchors,"index",Doxygen::mainPage);
9686 Doxygen::mainPage->setBriefDescription(root->brief,root->briefFile,root->briefLine);
9687 Doxygen::mainPage->setBodySegment(root->startLine,root->startLine,-1);
9688 Doxygen::mainPage->setFileName(indexName);
9689 Doxygen::mainPage->setLocalToc(root->localToc);
9691
9693 if (si)
9694 {
9695 if (!si->ref().isEmpty()) // we are from a tag file
9696 {
9697 // a page name is a label as well! but should no be double either
9699 Doxygen::mainPage->name(),
9700 indexName,
9701 root->startLine,
9702 Doxygen::mainPage->title(),
9704 0); // level 0
9705 }
9706 else if (si->lineNr() != -1)
9707 {
9708 warn(root->fileName,root->startLine,"multiple use of section label '{}' for main page, (first occurrence: {}, line {})",
9709 Doxygen::mainPage->name(),si->fileName(),si->lineNr());
9710 }
9711 else
9712 {
9713 warn(root->fileName,root->startLine,"multiple use of section label '{}' for main page, (first occurrence: {})",
9714 Doxygen::mainPage->name(),si->fileName());
9715 }
9716 }
9717 else
9718 {
9719 // a page name is a label as well! but should no be double either
9721 Doxygen::mainPage->name(),
9722 indexName,
9723 root->startLine,
9724 Doxygen::mainPage->title(),
9726 0); // level 0
9727 }
9728 Doxygen::mainPage->addSectionsToDefinition(root->anchors);
9729 }
9730 else if (root->tagInfo()==nullptr)
9731 {
9732 warn(root->fileName,root->startLine,
9733 "found more than one \\mainpage comment block! (first occurrence: {}, line {}), Skipping current block!",
9734 Doxygen::mainPage->docFile(),Doxygen::mainPage->getStartBodyLine());
9735 }
9736 }
9737 for (const auto &e : root->children()) findMainPage(e.get());
9738}
9739
9740// search for the main page imported via tag files and add only the section labels
9741static void findMainPageTagFiles(Entry *root)
9742{
9743 if (root->section.isMainpageDoc())
9744 {
9745 if (Doxygen::mainPage && root->tagInfo())
9746 {
9747 Doxygen::mainPage->addSectionsToDefinition(root->anchors);
9748 }
9749 }
9750 for (const auto &e : root->children()) findMainPageTagFiles(e.get());
9751}
9752
9753static void computePageRelations(Entry *root)
9754{
9755 if ((root->section.isPageDoc() || root->section.isMainpageDoc()) && !root->name.isEmpty())
9756 {
9757 PageDef *pd = root->section.isPageDoc() ?
9758 Doxygen::pageLinkedMap->find(root->name) :
9759 Doxygen::mainPage.get();
9760 if (pd)
9761 {
9762 for (const BaseInfo &bi : root->extends)
9763 {
9764 PageDef *subPd = Doxygen::pageLinkedMap->find(bi.name);
9765 if (pd==subPd)
9766 {
9767 term("page defined {} with label {} is a direct "
9768 "subpage of itself! Please remove this cyclic dependency.\n",
9769 warn_line(pd->docFile(),pd->docLine()),pd->name());
9770 }
9771 else if (subPd)
9772 {
9773 pd->addInnerCompound(subPd);
9774 //printf("*** Added subpage relation: %s->%s\n",
9775 // qPrint(pd->name()),qPrint(subPd->name()));
9776 }
9777 }
9778 }
9779 }
9780 for (const auto &e : root->children()) computePageRelations(e.get());
9781}
9782
9784{
9785 for (const auto &pd : *Doxygen::pageLinkedMap)
9786 {
9787 Definition *ppd = pd->getOuterScope();
9788 while (ppd)
9789 {
9790 if (ppd==pd.get())
9791 {
9792 term("page defined {} with label {} is a subpage "
9793 "of itself! Please remove this cyclic dependency.\n",
9794 warn_line(pd->docFile(),pd->docLine()),pd->name());
9795 }
9796 ppd=ppd->getOuterScope();
9797 }
9798 }
9799}
9800
9801//----------------------------------------------------------------------------
9802
9804{
9805 for (const auto &si : SectionManager::instance())
9806 {
9807 //printf("si->label='%s' si->definition=%s si->fileName='%s'\n",
9808 // qPrint(si->label),si->definition?qPrint(si->definition->name()):"<none>",
9809 // qPrint(si->fileName));
9810 PageDef *pd=nullptr;
9811
9812 // hack: the items of a todo/test/bug/deprecated list are all fragments from
9813 // different files, so the resulting section's all have the wrong file
9814 // name (not from the todo/test/bug/deprecated list, but from the file in
9815 // which they are defined). We correct this here by looking at the
9816 // generated section labels!
9818 {
9819 QCString label="_"+rl->listName(); // "_todo", "_test", ...
9820 if (si->label().left(label.length())==label)
9821 {
9822 si->setFileName(rl->listName());
9823 si->setGenerated(TRUE);
9824 break;
9825 }
9826 }
9827
9828 //printf("start: si->label=%s si->fileName=%s\n",qPrint(si->label),qPrint(si->fileName));
9829 if (!si->generated())
9830 {
9831 // if this section is in a page and the page is in a group, then we
9832 // have to adjust the link file name to point to the group.
9833 if (!si->fileName().isEmpty() &&
9834 (pd=Doxygen::pageLinkedMap->find(si->fileName())) &&
9835 pd->getGroupDef())
9836 {
9837 si->setFileName(pd->getGroupDef()->getOutputFileBase());
9838 }
9839
9840 if (si->definition())
9841 {
9842 // TODO: there should be one function in Definition that returns
9843 // the file to link to, so we can avoid the following tests.
9844 const GroupDef *gd=nullptr;
9845 if (si->definition()->definitionType()==Definition::TypeMember)
9846 {
9847 gd = (toMemberDef(si->definition()))->getGroupDef();
9848 }
9849
9850 if (gd)
9851 {
9852 si->setFileName(gd->getOutputFileBase());
9853 }
9854 else
9855 {
9856 //si->fileName=si->definition->getOutputFileBase();
9857 //printf("Setting si->fileName to %s\n",qPrint(si->fileName));
9858 }
9859 }
9860 }
9861 //printf("end: si->label=%s si->fileName=%s\n",qPrint(si->label),qPrint(si->fileName));
9862 }
9863}
9864
9865
9866
9867//----------------------------------------------------------------------------
9868// generate all separate documentation pages
9869
9870
9871static void generatePageDocs()
9872{
9873 //printf("documentedPages=%d real=%d\n",documentedPages,Doxygen::pageLinkedMap->count());
9874 if (Index::instance().numDocumentedPages()==0) return;
9875 for (const auto &pd : *Doxygen::pageLinkedMap)
9876 {
9877 if (!pd->getGroupDef() && !pd->isReference())
9878 {
9879 msg("Generating docs for page {}...\n",pd->name());
9880 pd->writeDocumentation(*g_outputList);
9881 }
9882 }
9883}
9884
9885//----------------------------------------------------------------------------
9886// create a (sorted) list & dictionary of example pages
9887
9888static void buildExampleList(Entry *root)
9889{
9890 if ((root->section.isExample() || root->section.isExampleLineno()) && !root->name.isEmpty())
9891 {
9892 if (Doxygen::exampleLinkedMap->find(root->name))
9893 {
9894 warn(root->fileName,root->startLine,"Example {} was already documented. Ignoring documentation found here.",root->name);
9895 }
9896 else
9897 {
9898 PageDef *pd = Doxygen::exampleLinkedMap->add(root->name,
9899 createPageDef(root->fileName,root->startLine,
9900 root->name,root->brief+root->doc+root->inbodyDocs,root->args));
9901 pd->setBriefDescription(root->brief,root->briefFile,root->briefLine);
9902 pd->setFileName(convertNameToFile(pd->name()+"-example",FALSE,TRUE));
9904 pd->setLanguage(root->lang);
9905 pd->setShowLineNo(root->section.isExampleLineno());
9906
9907 //we don't add example to groups
9908 //addExampleToGroups(root,pd);
9909 }
9910 }
9911 for (const auto &e : root->children()) buildExampleList(e.get());
9912}
9913
9914//----------------------------------------------------------------------------
9915// prints the Entry tree (for debugging)
9916
9917void printNavTree(Entry *root,int indent)
9918{
9920 {
9921 QCString indentStr;
9922 indentStr.fill(' ',indent);
9923 Debug::print(Debug::Entries,0,"{}{} at {}:{} (sec={}, spec={})\n",
9924 indentStr.isEmpty()?"":indentStr,
9925 root->name.isEmpty()?"<empty>":root->name,
9926 root->fileName,root->startLine,
9927 root->section.to_string(),
9928 root->spec.to_string());
9929 for (const auto &e : root->children())
9930 {
9931 printNavTree(e.get(),indent+2);
9932 }
9933 }
9934}
9935
9936
9937//----------------------------------------------------------------------------
9938// prints the Sections tree (for debugging)
9939
9941{
9943 {
9944 for (const auto &si : SectionManager::instance())
9945 {
9946 Debug::print(Debug::Sections,0,"Section = {}, file = {}, title = {}, type = {}, ref = {}\n",
9947 si->label(),si->fileName(),si->title(),si->type().level(),si->ref());
9948 }
9949 }
9950}
9951
9952
9953//----------------------------------------------------------------------------
9954// generate the example documentation
9955
9957{
9958 g_outputList->disable(OutputType::Man);
9959 for (const auto &pd : *Doxygen::exampleLinkedMap)
9960 {
9961 msg("Generating docs for example {}...\n",pd->name());
9962 SrcLangExt lang = getLanguageFromFileName(pd->name(), SrcLangExt::Unknown);
9963 if (lang != SrcLangExt::Unknown)
9964 {
9965 QCString ext = getFileNameExtension(pd->name());
9966 auto intf = Doxygen::parserManager->getCodeParser(ext);
9967 intf->resetCodeParserState();
9968 }
9969 QCString n=pd->getOutputFileBase();
9970 startFile(*g_outputList,n,n,pd->name());
9972 g_outputList->docify(pd->name());
9974 g_outputList->startContents();
9975 QCString lineNoOptStr;
9976 if (pd->showLineNo())
9977 {
9978 lineNoOptStr="{lineno}";
9979 }
9980 g_outputList->generateDoc(pd->docFile(), // file
9981 pd->docLine(), // startLine
9982 pd.get(), // context
9983 nullptr, // memberDef
9984 (pd->briefDescription().isEmpty()?"":pd->briefDescription()+"\n\n")+
9985 pd->documentation()+"\n\n\\include"+lineNoOptStr+" "+pd->name(), // docs
9986 TRUE, // index words
9987 TRUE, // is example
9988 pd->name(),
9989 FALSE,
9990 FALSE
9991 );
9992 endFile(*g_outputList); // contains g_outputList->endContents()
9993 }
9995}
9996
9997//----------------------------------------------------------------------------
9998// generate module pages
9999
10001{
10002 for (const auto &gd : *Doxygen::groupLinkedMap)
10003 {
10004 if (!gd->isReference())
10005 {
10006 gd->writeDocumentation(*g_outputList);
10007 }
10008 }
10009}
10010
10011//----------------------------------------------------------------------------
10012// generate module pages
10013
10015{
10016 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
10017 if (numThreads>1) // multi threaded processing
10018 {
10019 struct DocContext
10020 {
10021 DocContext(ClassDefMutable *cdm_,const OutputList &ol_)
10022 : cdm(cdm_), ol(ol_) {}
10023 ClassDefMutable *cdm;
10024 OutputList ol;
10025 };
10026 ThreadPool threadPool(numThreads);
10027 std::vector< std::future< std::shared_ptr<DocContext> > > results;
10028 // for each class in the namespace...
10029 for (const auto &cd : classList)
10030 {
10032 if (cdm)
10033 {
10034 auto ctx = std::make_shared<DocContext>(cdm,*g_outputList);
10035 auto processFile = [ctx]()
10036 {
10037 if ( ( ctx->cdm->isLinkableInProject() &&
10038 !ctx->cdm->isImplicitTemplateInstance()
10039 ) // skip external references, anonymous compounds and
10040 // template instances and nested classes
10041 && !ctx->cdm->isHidden() && !ctx->cdm->isEmbeddedInOuterScope()
10042 )
10043 {
10044 msg("Generating docs for compound {}...\n",ctx->cdm->displayName());
10045 ctx->cdm->writeDocumentation(ctx->ol);
10046 ctx->cdm->writeMemberList(ctx->ol);
10047 }
10048 ctx->cdm->writeDocumentationForInnerClasses(ctx->ol);
10049 return ctx;
10050 };
10051 results.emplace_back(threadPool.queue(processFile));
10052 }
10053 }
10054 // wait for the results
10055 for (auto &f : results)
10056 {
10057 auto ctx = f.get();
10058 }
10059 }
10060 else // single threaded processing
10061 {
10062 // for each class in the namespace...
10063 for (const auto &cd : classList)
10064 {
10066 if (cdm)
10067 {
10068 if ( ( cd->isLinkableInProject() &&
10069 !cd->isImplicitTemplateInstance()
10070 ) // skip external references, anonymous compounds and
10071 // template instances and nested classes
10072 && !cd->isHidden() && !cd->isEmbeddedInOuterScope()
10073 )
10074 {
10075 msg("Generating docs for compound {}...\n",cd->displayName());
10076
10079 }
10081 }
10082 }
10083 }
10084}
10085
10087{
10088 // for each concept in the namespace...
10089 for (const auto &cd : conceptList)
10090 {
10092 if ( cdm && cd->isLinkableInProject() && !cd->isHidden())
10093 {
10094 msg("Generating docs for concept {}...\n",cd->name());
10096 }
10097 }
10098}
10099
10101{
10102 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
10103
10104 //writeNamespaceIndex(*g_outputList);
10105
10106 // for each namespace...
10107 for (const auto &nd : *Doxygen::namespaceLinkedMap)
10108 {
10109 if (nd->isLinkableInProject())
10110 {
10112 if (ndm)
10113 {
10114 msg("Generating docs for namespace {}\n",nd->displayName());
10116 }
10117 }
10118
10119 generateNamespaceClassDocs(nd->getClasses());
10120 if (sliceOpt)
10121 {
10122 generateNamespaceClassDocs(nd->getInterfaces());
10123 generateNamespaceClassDocs(nd->getStructs());
10124 generateNamespaceClassDocs(nd->getExceptions());
10125 }
10126 generateNamespaceConceptDocs(nd->getConcepts());
10127 }
10128}
10129
10131{
10132 std::string oldDir = Dir::currentDirPath();
10133 Dir::setCurrent(Config_getString(HTML_OUTPUT).str());
10136 {
10137 err("failed to run html help compiler on {}\n", HtmlHelp::hhpFileName);
10138 }
10139 Dir::setCurrent(oldDir);
10140}
10141
10143{
10144 QCString args = Qhp::qhpFileName + " -o \"" + Qhp::getQchFileName() + "\"";
10145 std::string oldDir = Dir::currentDirPath();
10146 Dir::setCurrent(Config_getString(HTML_OUTPUT).str());
10147
10148 QCString qhgLocation=Config_getString(QHG_LOCATION);
10149 if (Debug::isFlagSet(Debug::Qhp)) // produce info for debugging
10150 {
10151 // run qhelpgenerator -v and extract the Qt version used
10152 QCString cmd=qhgLocation+ " -v 2>&1";
10153 Debug::print(Debug::ExtCmd,0,"Executing popen(`{}`)\n",cmd);
10154 FILE *f=Portable::popen(cmd,"r");
10155 if (!f)
10156 {
10157 err("could not execute {}\n",qhgLocation);
10158 }
10159 else
10160 {
10161 const size_t bufSize = 1024;
10162 char inBuf[bufSize+1];
10163 size_t numRead=fread(inBuf,1,bufSize,f);
10164 inBuf[numRead] = '\0';
10165 Debug::print(Debug::Qhp,0,"{}",inBuf);
10167
10168 int qtVersion=0;
10169 static const reg::Ex versionReg(R"(Qt (\d+)\.(\d+)\.(\d+))");
10170 reg::Match match;
10171 std::string s = inBuf;
10172 if (reg::search(inBuf,match,versionReg))
10173 {
10174 qtVersion = 10000*QCString(match[1].str()).toInt() +
10175 100*QCString(match[2].str()).toInt() +
10176 QCString(match[3].str()).toInt();
10177 }
10178 if (qtVersion>0 && (qtVersion<60000 || qtVersion >= 60205))
10179 {
10180 // dump the output of qhelpgenerator -c file.qhp
10181 // Qt<6 or Qt>=6.2.5 or higher, see https://bugreports.qt.io/browse/QTBUG-101070
10182 cmd=qhgLocation+ " -c " + Qhp::qhpFileName + " 2>&1";
10183 Debug::print(Debug::ExtCmd,0,"Executing popen(`{}`)\n",cmd);
10184 f=Portable::popen(cmd,"r");
10185 if (!f)
10186 {
10187 err("could not execute {}\n",qhgLocation);
10188 }
10189 else
10190 {
10191 std::string output;
10192 while ((numRead=fread(inBuf,1,bufSize,f))>0)
10193 {
10194 inBuf[numRead] = '\0';
10195 output += inBuf;
10196 }
10198 Debug::print(Debug::Qhp,0,"{}",output);
10199 }
10200 }
10201 }
10202 }
10203
10204 if (Portable::system(qhgLocation, args, FALSE))
10205 {
10206 err("failed to run qhelpgenerator on {}\n",Qhp::qhpFileName);
10207 }
10208 Dir::setCurrent(oldDir);
10209}
10210
10211//----------------------------------------------------------------------------
10212
10214{
10215 // check dot path
10216 QCString dotPath = Config_getString(DOT_PATH);
10217 if (!dotPath.isEmpty())
10218 {
10219 FileInfo fi(dotPath.str());
10220 if (!(fi.exists() && fi.isFile()) )// not an existing user specified path + exec
10221 {
10222 dotPath = dotPath+"/dot"+Portable::commandExtension();
10223 FileInfo dp(dotPath.str());
10224 if (!dp.exists() || !dp.isFile())
10225 {
10226 warn_uncond("the dot tool could not be found as '{}'\n",dotPath);
10227 dotPath = "dot";
10228 dotPath += Portable::commandExtension();
10229 }
10230 }
10231#if defined(_WIN32) // convert slashes
10232 size_t l=dotPath.length();
10233 for (size_t i=0;i<l;i++) if (dotPath.at(i)=='/') dotPath.at(i)='\\';
10234#endif
10235 }
10236 else
10237 {
10238 dotPath = "dot";
10239 dotPath += Portable::commandExtension();
10240 }
10241 Doxygen::verifiedDotPath = dotPath;
10243}
10244
10245//----------------------------------------------------------------------------
10246
10247/*! Generate a template version of the configuration file.
10248 * If the \a shortList parameter is TRUE a configuration file without
10249 * comments will be generated.
10250 */
10251static void generateConfigFile(const QCString &configFile,bool shortList,
10252 bool updateOnly=FALSE)
10253{
10254 std::ofstream f;
10255 bool fileOpened=openOutputFile(configFile,f);
10256 bool writeToStdout=configFile=="-";
10257 if (fileOpened)
10258 {
10259 TextStream t(&f);
10260 Config::writeTemplate(t,shortList,updateOnly);
10261 if (!writeToStdout)
10262 {
10263 if (!updateOnly)
10264 {
10265 msg("\n\nConfiguration file '{}' created.\n\n",configFile);
10266 msg("Now edit the configuration file and enter\n\n");
10267 if (configFile!="Doxyfile" && configFile!="doxyfile")
10268 msg(" doxygen {}\n\n",configFile);
10269 else
10270 msg(" doxygen\n\n");
10271 msg("to generate the documentation for your project\n\n");
10272 }
10273 else
10274 {
10275 msg("\n\nConfiguration file '{}' updated.\n\n",configFile);
10276 }
10277 }
10278 }
10279 else
10280 {
10281 term("Cannot open file {} for writing\n",configFile);
10282 }
10283}
10284
10286{
10287 std::ofstream f;
10288 bool fileOpened=openOutputFile("-",f);
10289 if (fileOpened)
10290 {
10291 TextStream t(&f);
10292 Config::compareDoxyfile(t,diffList);
10293 }
10294 else
10295 {
10296 term("Cannot open stdout for writing\n");
10297 }
10298}
10299
10300//----------------------------------------------------------------------------
10301// read and parse a tag file
10302
10303static void readTagFile(const std::shared_ptr<Entry> &root,const QCString &tagLine)
10304{
10305 QCString fileName;
10306 QCString destName;
10307 int eqPos = tagLine.find('=');
10308 if (eqPos!=-1) // tag command contains a destination
10309 {
10310 fileName = tagLine.left(eqPos).stripWhiteSpace();
10311 destName = tagLine.right(tagLine.length()-eqPos-1).stripWhiteSpace();
10312 if (fileName.isEmpty() || destName.isEmpty()) return;
10313 //printf("insert tagDestination %s->%s\n",qPrint(fi.fileName()),qPrint(destName));
10314 }
10315 else
10316 {
10317 fileName = tagLine;
10318 }
10319
10320 FileInfo fi(fileName.str());
10321 if (!fi.exists() || !fi.isFile())
10322 {
10323 err("Tag file '{}' does not exist or is not a file. Skipping it...\n",fileName);
10324 return;
10325 }
10326
10327 if (Doxygen::tagFileSet.find(fi.absFilePath().c_str()) != Doxygen::tagFileSet.end()) return;
10328
10329 Doxygen::tagFileSet.emplace(fi.absFilePath());
10330
10331 if (!destName.isEmpty())
10332 {
10333 Doxygen::tagDestinationMap.emplace(fi.absFilePath(), destName.str());
10334 msg("Reading tag file '{}', location '{}'...\n",fileName,destName);
10335 }
10336 else
10337 {
10338 msg("Reading tag file '{}'...\n",fileName);
10339 }
10340
10341 parseTagFile(root,fi.absFilePath().c_str());
10342}
10343
10344//----------------------------------------------------------------------------
10346{
10347 const StringVector &latexExtraStyleSheet = Config_getList(LATEX_EXTRA_STYLESHEET);
10348 for (const auto &sheet : latexExtraStyleSheet)
10349 {
10350 std::string fileName = sheet;
10351 if (!fileName.empty())
10352 {
10353 FileInfo fi(fileName);
10354 if (!fi.exists())
10355 {
10356 err("Style sheet '{}' specified by LATEX_EXTRA_STYLESHEET does not exist!\n",fileName);
10357 }
10358 else if (fi.isDir())
10359 {
10360 err("Style sheet '{}' specified by LATEX_EXTRA_STYLESHEET is a directory, it has to be a file!\n", fileName);
10361 }
10362 else
10363 {
10364 QCString destFileName = Config_getString(LATEX_OUTPUT)+"/"+fi.fileName();
10365 if (!checkExtension(fi.fileName().c_str(), LATEX_STYLE_EXTENSION))
10366 {
10367 destFileName += LATEX_STYLE_EXTENSION;
10368 }
10369 copyFile(QCString(fileName), destFileName);
10370 }
10371 }
10372 }
10373}
10374
10375//----------------------------------------------------------------------------
10376static void copyStyleSheet()
10377{
10378 QCString htmlStyleSheet = Config_getString(HTML_STYLESHEET);
10379 if (!htmlStyleSheet.isEmpty())
10380 {
10381 if (!htmlStyleSheet.startsWith("http:") && !htmlStyleSheet.startsWith("https:"))
10382 {
10383 FileInfo fi(htmlStyleSheet.str());
10384 if (!fi.exists())
10385 {
10386 err("Style sheet '{}' specified by HTML_STYLESHEET does not exist!\n",htmlStyleSheet);
10387 htmlStyleSheet = Config_updateString(HTML_STYLESHEET,""); // revert to the default
10388 }
10389 else if (fi.isDir())
10390 {
10391 err("Style sheet '{}' specified by HTML_STYLESHEET is a directory, it has to be a file!\n",htmlStyleSheet);
10392 htmlStyleSheet = Config_updateString(HTML_STYLESHEET,""); // revert to the default
10393 }
10394 else
10395 {
10396 QCString destFileName = Config_getString(HTML_OUTPUT)+"/"+fi.fileName();
10397 copyFile(htmlStyleSheet,destFileName);
10398 }
10399 }
10400 }
10401 const StringVector &htmlExtraStyleSheet = Config_getList(HTML_EXTRA_STYLESHEET);
10402 for (const auto &sheet : htmlExtraStyleSheet)
10403 {
10404 QCString fileName(sheet);
10405 if (!fileName.isEmpty() && !fileName.startsWith("http:") && !fileName.startsWith("https:"))
10406 {
10407 FileInfo fi(fileName.str());
10408 if (!fi.exists())
10409 {
10410 err("Style sheet '{}' specified by HTML_EXTRA_STYLESHEET does not exist!\n",fileName);
10411 }
10412 else if (fi.fileName()=="doxygen.css" || fi.fileName()=="tabs.css" || fi.fileName()=="navtree.css")
10413 {
10414 err("Style sheet '{}' specified by HTML_EXTRA_STYLESHEET is already a built-in stylesheet. Please use a different name\n",fi.fileName());
10415 }
10416 else if (fi.isDir())
10417 {
10418 err("Style sheet '{}' specified by HTML_EXTRA_STYLESHEET is a directory, it has to be a file!\n",fileName);
10419 }
10420 else
10421 {
10422 QCString destFileName = Config_getString(HTML_OUTPUT)+"/"+fi.fileName();
10423 copyFile(QCString(fileName), destFileName);
10424 }
10425 }
10426 }
10427}
10428
10429static void copyLogo(const QCString &outputOption)
10430{
10431 QCString projectLogo = projectLogoFile();
10432 if (!projectLogo.isEmpty())
10433 {
10434 FileInfo fi(projectLogo.str());
10435 if (!fi.exists())
10436 {
10437 err("Project logo '{}' specified by PROJECT_LOGO does not exist!\n",projectLogo);
10438 projectLogo = Config_updateString(PROJECT_LOGO,""); // revert to the default
10439 }
10440 else if (fi.isDir())
10441 {
10442 err("Project logo '{}' specified by PROJECT_LOGO is a directory, it has to be a file!\n",projectLogo);
10443 projectLogo = Config_updateString(PROJECT_LOGO,""); // revert to the default
10444 }
10445 else
10446 {
10447 QCString destFileName = outputOption+"/"+fi.fileName();
10448 copyFile(projectLogo,destFileName);
10449 Doxygen::indexList->addImageFile(fi.fileName().c_str());
10450 }
10451 }
10452}
10453
10454static void copyIcon(const QCString &outputOption)
10455{
10456 QCString projectIcon = Config_getString(PROJECT_ICON);
10457 if (!projectIcon.isEmpty())
10458 {
10459 FileInfo fi(projectIcon.str());
10460 if (!fi.exists())
10461 {
10462 err("Project icon '{}' specified by PROJECT_ICON does not exist!\n",projectIcon);
10463 projectIcon = Config_updateString(PROJECT_ICON,""); // revert to the default
10464 }
10465 else if (fi.isDir())
10466 {
10467 err("Project icon '{}' specified by PROJECT_ICON is a directory, it has to be a file!\n",projectIcon);
10468 projectIcon = Config_updateString(PROJECT_ICON,""); // revert to the default
10469 }
10470 else
10471 {
10472 QCString destFileName = outputOption+"/"+fi.fileName();
10473 copyFile(projectIcon,destFileName);
10474 Doxygen::indexList->addImageFile(fi.fileName().c_str());
10475 }
10476 }
10477}
10478
10479static void copyExtraFiles(const StringVector &files,const QCString &filesOption,const QCString &outputOption)
10480{
10481 for (const auto &fileName : files)
10482 {
10483 if (!fileName.empty())
10484 {
10485 FileInfo fi(fileName);
10486 if (!fi.exists())
10487 {
10488 err("Extra file '{}' specified in {} does not exist!\n", fileName,filesOption);
10489 }
10490 else if (fi.isDir())
10491 {
10492 err("Extra file '{}' specified in {} is a directory, it has to be a file!\n", fileName,filesOption);
10493 }
10494 else
10495 {
10496 QCString destFileName = outputOption+"/"+fi.fileName();
10497 Doxygen::indexList->addImageFile(fi.fileName().c_str());
10498 copyFile(QCString(fileName), destFileName);
10499 }
10500 }
10501 }
10502}
10503
10504//----------------------------------------------------------------------------
10505
10507{
10508 for (const auto &fn : *Doxygen::inputNameLinkedMap)
10509 {
10510 struct FileEntry
10511 {
10512 FileEntry(const QCString &p,FileDef *fd) : path(p), fileDef(fd) {}
10513 QCString path;
10514 FileDef *fileDef;
10515 };
10516
10517 // collect the entry for which to compute the longest common prefix (LCP) of the path
10518 std::vector<FileEntry> fileEntries;
10519 for (const auto &fd : *fn)
10520 {
10521 if (!fd->isReference()) // skip external references
10522 {
10523 fileEntries.emplace_back(fd->getPath(),fd.get());
10524 }
10525 }
10526
10527 size_t size = fileEntries.size();
10528
10529 if (size==1) // name if unique, so diskname is simply the name
10530 {
10531 FileDef *fd = fileEntries[0].fileDef;
10532 fd->setDiskName(fn->fileName());
10533 }
10534 else if (size>1) // multiple occurrences of the same file name
10535 {
10536 // sort the array
10537 std::stable_sort(fileEntries.begin(),
10538 fileEntries.end(),
10539 [](const FileEntry &fe1,const FileEntry &fe2)
10540 { return qstricmp_sort(fe1.path,fe2.path)<0; }
10541 );
10542
10543 // since the entries are sorted, the common prefix of the whole array is same
10544 // as the common prefix between the first and last entry
10545 const FileEntry &first = fileEntries[0];
10546 const FileEntry &last = fileEntries[size-1];
10547 int first_path_size = static_cast<int>(first.path.size())-1; // -1 to skip trailing slash
10548 int last_path_size = static_cast<int>(last.path.size())-1; // -1 to skip trailing slash
10549 int j=0;
10550 int i=0;
10551 for (i=0;i<first_path_size && i<last_path_size;i++)
10552 {
10553 if (first.path[i]=='/') j=i;
10554 if (first.path[i]!=last.path[i]) break;
10555 }
10556 if (i==first_path_size && i<last_path_size && last.path[i]=='/')
10557 {
10558 // case first='some/path' and last='some/path/more' => match is 'some/path'
10559 j=first_path_size;
10560 }
10561 else if (i==last_path_size && i<first_path_size && first.path[i]=='/')
10562 {
10563 // case first='some/path/more' and last='some/path' => match is 'some/path'
10564 j=last_path_size;
10565 }
10566
10567 // add non-common part of the path to the name
10568 for (auto &fileEntry : fileEntries)
10569 {
10570 QCString prefix = fileEntry.path.right(fileEntry.path.length()-j-1);
10571 fileEntry.fileDef->setName(prefix+fn->fileName());
10572 //printf("!!!!!!!! non unique disk name=%s:%s\n",qPrint(prefix),fn->fileName());
10573 fileEntry.fileDef->setDiskName(prefix+fn->fileName());
10574 }
10575 }
10576 }
10577}
10578
10579
10580
10581//----------------------------------------------------------------------------
10582
10583static std::unique_ptr<OutlineParserInterface> getParserForFile(const QCString &fn)
10584{
10585 QCString fileName=fn;
10586 QCString extension;
10587 int sep = fileName.findRev('/');
10588 int ei = fileName.findRev('.');
10589 if (ei!=-1 && (sep==-1 || ei>sep)) // matches dir/file.ext but not dir.1/file
10590 {
10591 extension=fileName.right(fileName.length()-ei);
10592 }
10593 else
10594 {
10595 extension = ".no_extension";
10596 }
10597
10598 return Doxygen::parserManager->getOutlineParser(extension);
10599}
10600
10601static std::shared_ptr<Entry> parseFile(OutlineParserInterface &parser,
10602 FileDef *fd,const QCString &fn,
10603 ClangTUParser *clangParser,bool newTU)
10604{
10605 QCString fileName=fn;
10606 AUTO_TRACE("fileName={}",fileName);
10607 QCString extension;
10608 int ei = fileName.findRev('.');
10609 if (ei!=-1)
10610 {
10611 extension=fileName.right(fileName.length()-ei);
10612 }
10613 else
10614 {
10615 extension = ".no_extension";
10616 }
10617
10618 FileInfo fi(fileName.str());
10619 std::string preBuf;
10620
10621 if (Config_getBool(ENABLE_PREPROCESSING) &&
10622 parser.needsPreprocessing(extension))
10623 {
10624 Preprocessor preprocessor;
10625 const StringVector &includePath = Config_getList(INCLUDE_PATH);
10626 for (const auto &s : includePath)
10627 {
10628 std::string absPath = FileInfo(s).absFilePath();
10629 preprocessor.addSearchDir(absPath.c_str());
10630 }
10631 std::string inBuf;
10632 msg("Preprocessing {}...\n",fn);
10633 readInputFile(fileName,inBuf);
10634 addTerminalCharIfMissing(inBuf,'\n');
10635 preprocessor.processFile(fileName,inBuf,preBuf);
10636 }
10637 else // no preprocessing
10638 {
10639 msg("Reading {}...\n",fn);
10640 readInputFile(fileName,preBuf);
10641 addTerminalCharIfMissing(preBuf,'\n');
10642 }
10643
10644 std::string convBuf;
10645 convBuf.reserve(preBuf.size()+1024);
10646
10647 // convert multi-line C++ comments to C style comments
10648 convertCppComments(preBuf,convBuf,fileName.str());
10649
10650 std::shared_ptr<Entry> fileRoot = std::make_shared<Entry>();
10651 // use language parse to parse the file
10652 if (clangParser)
10653 {
10654 if (newTU) clangParser->parse();
10655 clangParser->switchToFile(fd);
10656 }
10657 parser.parseInput(fileName,convBuf.data(),fileRoot,clangParser);
10658 fileRoot->setFileDef(fd);
10659 return fileRoot;
10660}
10661
10662//! parse the list of input files
10663static void parseFilesMultiThreading(const std::shared_ptr<Entry> &root)
10664{
10665 AUTO_TRACE();
10666#if USE_LIBCLANG
10668 {
10669 StringUnorderedSet processedFiles;
10670
10671 // create a dictionary with files to process
10672 StringUnorderedSet filesToProcess;
10673 for (const auto &s : g_inputFiles)
10674 {
10675 filesToProcess.insert(s);
10676 }
10677
10678 std::mutex processedFilesLock;
10679 // process source files (and their include dependencies)
10680 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
10681 msg("Processing input using {} threads.\n",numThreads);
10682 ThreadPool threadPool(numThreads);
10683 using FutureType = std::vector< std::shared_ptr<Entry> >;
10684 std::vector< std::future< FutureType > > results;
10685 for (const auto &s : g_inputFiles)
10686 {
10687 bool ambig = false;
10689 ASSERT(fd!=nullptr);
10690 if (fd->isSource() && !fd->isReference() && fd->getLanguage()==SrcLangExt::Cpp) // this is a source file
10691 {
10692 // lambda representing the work to executed by a thread
10693 auto processFile = [s,&filesToProcess,&processedFilesLock,&processedFiles]() {
10694 bool ambig_l = false;
10695 std::vector< std::shared_ptr<Entry> > roots;
10696 FileDef *fd_l = findFileDef(Doxygen::inputNameLinkedMap,s.c_str(),ambig_l);
10697 auto clangParser = ClangParser::instance()->createTUParser(fd_l);
10698 auto parser = getParserForFile(s.c_str());
10699 auto fileRoot { parseFile(*parser.get(),fd_l,s.c_str(),clangParser.get(),true) };
10700 roots.push_back(fileRoot);
10701
10702 // Now process any include files in the same translation unit
10703 // first. When libclang is used this is much more efficient.
10704 for (auto incFile : clangParser->filesInSameTU())
10705 {
10706 if (filesToProcess.find(incFile)!=filesToProcess.end())
10707 {
10708 bool needsToBeProcessed = false;
10709 {
10710 std::lock_guard<std::mutex> lock(processedFilesLock);
10711 needsToBeProcessed = processedFiles.find(incFile)==processedFiles.end();
10712 if (needsToBeProcessed) processedFiles.insert(incFile);
10713 }
10714 if (incFile!=s && needsToBeProcessed)
10715 {
10716 FileDef *ifd=findFileDef(Doxygen::inputNameLinkedMap,incFile.c_str(),ambig_l);
10717 if (ifd && !ifd->isReference())
10718 {
10719 //printf(" Processing %s in same translation unit as %s\n",incFile,s->c_str());
10720 fileRoot = parseFile(*parser.get(),ifd,incFile.c_str(),clangParser.get(),false);
10721 roots.push_back(fileRoot);
10722 }
10723 }
10724 }
10725 }
10726 return roots;
10727 };
10728 // dispatch the work and collect the future results
10729 results.emplace_back(threadPool.queue(processFile));
10730 }
10731 }
10732 // synchronize with the Entry result lists produced and add them to the root
10733 for (auto &f : results)
10734 {
10735 auto l = f.get();
10736 for (auto &e : l)
10737 {
10738 root->moveToSubEntryAndKeep(e);
10739 }
10740 }
10741 // process remaining files
10742 results.clear();
10743 for (const auto &s : g_inputFiles)
10744 {
10745 if (processedFiles.find(s)==processedFiles.end()) // not yet processed
10746 {
10747 // lambda representing the work to executed by a thread
10748 auto processFile = [s]() {
10749 bool ambig = false;
10750 std::vector< std::shared_ptr<Entry> > roots;
10752 auto parser { getParserForFile(s.c_str()) };
10753 bool useClang = getLanguageFromFileName(s.c_str())==SrcLangExt::Cpp;
10754 if (useClang)
10755 {
10756 auto clangParser = ClangParser::instance()->createTUParser(fd);
10757 auto fileRoot = parseFile(*parser.get(),fd,s.c_str(),clangParser.get(),true);
10758 roots.push_back(fileRoot);
10759 }
10760 else
10761 {
10762 auto fileRoot = parseFile(*parser.get(),fd,s.c_str(),nullptr,true);
10763 roots.push_back(fileRoot);
10764 }
10765 return roots;
10766 };
10767 results.emplace_back(threadPool.queue(processFile));
10768 }
10769 }
10770 // synchronize with the Entry result lists produced and add them to the root
10771 for (auto &f : results)
10772 {
10773 auto l = f.get();
10774 for (auto &e : l)
10775 {
10776 root->moveToSubEntryAndKeep(e);
10777 }
10778 }
10779 }
10780 else // normal processing
10781#endif
10782 {
10783 std::size_t numThreads = static_cast<std::size_t>(Config_getInt(NUM_PROC_THREADS));
10784 msg("Processing input using {} threads.\n",numThreads);
10785 ThreadPool threadPool(numThreads);
10786 using FutureType = std::shared_ptr<Entry>;
10787 std::vector< std::future< FutureType > > results;
10788 for (const auto &s : g_inputFiles)
10789 {
10790 // lambda representing the work to executed by a thread
10791 auto processFile = [s]() {
10792 bool ambig = false;
10794 auto parser = getParserForFile(s.c_str());
10795 auto fileRoot = parseFile(*parser.get(),fd,s.c_str(),nullptr,true);
10796 return fileRoot;
10797 };
10798 // dispatch the work and collect the future results
10799 results.emplace_back(threadPool.queue(processFile));
10800 }
10801 // synchronize with the Entry results produced and add them to the root
10802 for (auto &f : results)
10803 {
10804 root->moveToSubEntryAndKeep(f.get());
10805 }
10806 }
10807}
10808
10809//! parse the list of input files
10810static void parseFilesSingleThreading(const std::shared_ptr<Entry> &root)
10811{
10812 AUTO_TRACE();
10813#if USE_LIBCLANG
10815 {
10816 StringUnorderedSet processedFiles;
10817
10818 // create a dictionary with files to process
10819 StringUnorderedSet filesToProcess;
10820 for (const auto &s : g_inputFiles)
10821 {
10822 filesToProcess.insert(s);
10823 }
10824
10825 // process source files (and their include dependencies)
10826 for (const auto &s : g_inputFiles)
10827 {
10828 bool ambig = false;
10830 ASSERT(fd!=nullptr);
10831 if (fd->isSource() && !fd->isReference() && getLanguageFromFileName(s.c_str())==SrcLangExt::Cpp) // this is a source file
10832 {
10833 auto clangParser = ClangParser::instance()->createTUParser(fd);
10834 auto parser { getParserForFile(s.c_str()) };
10835 auto fileRoot = parseFile(*parser.get(),fd,s.c_str(),clangParser.get(),true);
10836 root->moveToSubEntryAndKeep(fileRoot);
10837 processedFiles.insert(s);
10838
10839 // Now process any include files in the same translation unit
10840 // first. When libclang is used this is much more efficient.
10841 for (auto incFile : clangParser->filesInSameTU())
10842 {
10843 //printf(" file %s\n",incFile.c_str());
10844 if (filesToProcess.find(incFile)!=filesToProcess.end() && // file need to be processed
10845 processedFiles.find(incFile)==processedFiles.end()) // and is not processed already
10846 {
10847 FileDef *ifd=findFileDef(Doxygen::inputNameLinkedMap,incFile.c_str(),ambig);
10848 if (ifd && !ifd->isReference())
10849 {
10850 //printf(" Processing %s in same translation unit as %s\n",incFile.c_str(),s.c_str());
10851 fileRoot = parseFile(*parser.get(),ifd,incFile.c_str(),clangParser.get(),false);
10852 root->moveToSubEntryAndKeep(fileRoot);
10853 processedFiles.insert(incFile);
10854 }
10855 }
10856 }
10857 }
10858 }
10859 // process remaining files
10860 for (const auto &s : g_inputFiles)
10861 {
10862 if (processedFiles.find(s)==processedFiles.end()) // not yet processed
10863 {
10864 bool ambig = false;
10866 if (getLanguageFromFileName(s.c_str())==SrcLangExt::Cpp) // not yet processed
10867 {
10868 auto clangParser = ClangParser::instance()->createTUParser(fd);
10869 auto parser { getParserForFile(s.c_str()) };
10870 auto fileRoot = parseFile(*parser.get(),fd,s.c_str(),clangParser.get(),true);
10871 root->moveToSubEntryAndKeep(fileRoot);
10872 }
10873 else
10874 {
10875 std::unique_ptr<OutlineParserInterface> parser { getParserForFile(s.c_str()) };
10876 std::shared_ptr<Entry> fileRoot = parseFile(*parser.get(),fd,s.c_str(),nullptr,true);
10877 root->moveToSubEntryAndKeep(fileRoot);
10878 }
10879 processedFiles.insert(s);
10880 }
10881 }
10882 }
10883 else // normal processing
10884#endif
10885 {
10886 for (const auto &s : g_inputFiles)
10887 {
10888 bool ambig = false;
10890 ASSERT(fd!=nullptr);
10891 std::unique_ptr<OutlineParserInterface> parser { getParserForFile(s.c_str()) };
10892 std::shared_ptr<Entry> fileRoot = parseFile(*parser.get(),fd,s.c_str(),nullptr,true);
10893 root->moveToSubEntryAndKeep(std::move(fileRoot));
10894 }
10895 }
10896}
10897
10898// resolves a path that may include symlinks, if a recursive symlink is
10899// found an empty string is returned.
10900static std::string resolveSymlink(const std::string &path)
10901{
10902 int sepPos=0;
10903 int oldPos=0;
10904 StringUnorderedSet nonSymlinks;
10905 StringUnorderedSet known;
10906 QCString result(path);
10907 QCString oldPrefix = "/";
10908 do
10909 {
10910#if defined(_WIN32)
10911 // UNC path, skip server and share name
10912 if (sepPos==0 && (result.startsWith("//") || result.startsWith("\\\\")))
10913 sepPos = result.find('/',2);
10914 if (sepPos!=-1)
10915 sepPos = result.find('/',sepPos+1);
10916#else
10917 sepPos = result.find('/',sepPos+1);
10918#endif
10919 QCString prefix = sepPos==-1 ? result : result.left(sepPos);
10920 if (nonSymlinks.find(prefix.str())==nonSymlinks.end())
10921 {
10922 FileInfo fi(prefix.str());
10923 if (fi.isSymLink())
10924 {
10925 QCString target = fi.readLink();
10926 bool isRelative = FileInfo(target.str()).isRelative();
10927 if (isRelative)
10928 {
10929 target = Dir::cleanDirPath(oldPrefix.str()+"/"+target.str());
10930 }
10931 if (sepPos!=-1)
10932 {
10933 if (fi.isDir() && target.length()>0 && target.at(target.length()-1)!='/')
10934 {
10935 target+='/';
10936 }
10937 target+=result.mid(sepPos);
10938 }
10939 result = Dir::cleanDirPath(target.str());
10940 if (known.find(result.str())!=known.end()) return std::string(); // recursive symlink!
10941 known.insert(result.str());
10942 if (isRelative)
10943 {
10944 sepPos = oldPos;
10945 }
10946 else // link to absolute path
10947 {
10948 sepPos = 0;
10949 oldPrefix = "/";
10950 }
10951 }
10952 else
10953 {
10954 nonSymlinks.insert(prefix.str());
10955 oldPrefix = prefix;
10956 }
10957 oldPos = sepPos;
10958 }
10959 }
10960 while (sepPos!=-1);
10961 return Dir::cleanDirPath(result.str());
10962}
10963
10965
10966//----------------------------------------------------------------------------
10967// Read all files matching at least one pattern in 'patList' in the
10968// directory represented by 'fi'.
10969// The directory is read iff the recursiveFlag is set.
10970// The contents of all files is append to the input string
10971
10972static void readDir(FileInfo *fi,
10973 FileNameLinkedMap *fnMap,
10974 StringUnorderedSet *exclSet,
10975 const StringVector *patList,
10976 const StringVector *exclPatList,
10977 StringVector *resultList,
10978 StringUnorderedSet *resultSet,
10979 bool errorIfNotExist,
10980 bool recursive,
10981 StringUnorderedSet *killSet,
10982 StringUnorderedSet *paths
10983 )
10984{
10985 std::string dirName = fi->absFilePath();
10986 if (paths && !dirName.empty())
10987 {
10988 paths->insert(dirName);
10989 }
10990 //printf("%s isSymLink()=%d\n",qPrint(dirName),fi->isSymLink());
10991 if (fi->isSymLink())
10992 {
10993 dirName = resolveSymlink(dirName);
10994 if (dirName.empty())
10995 {
10996 //printf("RECURSIVE SYMLINK: %s\n",qPrint(dirName));
10997 return; // recursive symlink
10998 }
10999 }
11000
11001 if (g_pathsVisited.find(dirName)!=g_pathsVisited.end())
11002 {
11003 //printf("PATH ALREADY VISITED: %s\n",qPrint(dirName));
11004 return; // already visited path
11005 }
11006 g_pathsVisited.insert(dirName);
11007
11008 Dir dir(dirName);
11009 msg("Searching for files in directory {}\n", fi->absFilePath());
11010 //printf("killSet=%p count=%d\n",killSet,killSet ? (int)killSet->count() : -1);
11011
11012 StringVector dirResultList;
11013
11014 for (const auto &dirEntry : dir.iterator())
11015 {
11016 FileInfo cfi(dirEntry.path());
11017 if (exclSet==nullptr || exclSet->find(cfi.absFilePath())==exclSet->end())
11018 { // file should not be excluded
11019 //printf("killSet->find(%s)\n",qPrint(cfi->absFilePath()));
11020 if (Config_getBool(EXCLUDE_SYMLINKS) && cfi.isSymLink())
11021 {
11022 }
11023 else if (!cfi.exists() || !cfi.isReadable())
11024 {
11025 if (errorIfNotExist)
11026 {
11027 warn_uncond("source '{}' is not a readable file or directory... skipping.\n",cfi.absFilePath());
11028 }
11029 }
11030 else if (cfi.isFile() &&
11031 (patList==nullptr || patternMatch(cfi,*patList)) &&
11032 (exclPatList==nullptr || !patternMatch(cfi,*exclPatList)) &&
11033 (killSet==nullptr || killSet->find(cfi.absFilePath())==killSet->end())
11034 )
11035 {
11036 std::string name=cfi.fileName();
11037 std::string path=cfi.dirPath()+"/";
11038 std::string fullName=path+name;
11039 if (fnMap)
11040 {
11041 auto fd = createFileDef(QCString(path),QCString(name));
11042 FileName *fn=nullptr;
11043 if (!name.empty())
11044 {
11045 fn = fnMap->add(QCString(name),QCString(fullName));
11046 fn->push_back(std::move(fd));
11047 }
11048 }
11049 dirResultList.push_back(fullName);
11050 if (resultSet) resultSet->insert(fullName);
11051 if (killSet) killSet->insert(fullName);
11052 }
11053 else if (recursive &&
11054 cfi.isDir() &&
11055 (exclPatList==nullptr || !patternMatch(cfi,*exclPatList)) &&
11056 cfi.fileName().at(0)!='.') // skip "." ".." and ".dir"
11057 {
11058 FileInfo acfi(cfi.absFilePath());
11059 readDir(&acfi,fnMap,exclSet,
11060 patList,exclPatList,&dirResultList,resultSet,errorIfNotExist,
11061 recursive,killSet,paths);
11062 }
11063 }
11064 }
11065 if (resultList && !dirResultList.empty())
11066 {
11067 // sort the resulting list to make the order platform independent.
11068 std::stable_sort(dirResultList.begin(),
11069 dirResultList.end(),
11070 [](const auto &f1,const auto &f2) { return qstricmp_sort(f1.c_str(),f2.c_str())<0; });
11071
11072 // append the sorted results to resultList
11073 resultList->insert(resultList->end(), dirResultList.begin(), dirResultList.end());
11074 }
11075}
11076
11077
11078//----------------------------------------------------------------------------
11079// read a file or all files in a directory and append their contents to the
11080// input string. The names of the files are appended to the 'fiList' list.
11081
11083 FileNameLinkedMap *fnMap,
11084 StringUnorderedSet *exclSet,
11085 const StringVector *patList,
11086 const StringVector *exclPatList,
11087 StringVector *resultList,
11088 StringUnorderedSet *resultSet,
11089 bool recursive,
11090 bool errorIfNotExist,
11091 StringUnorderedSet *killSet,
11092 StringUnorderedSet *paths
11093 )
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}
11155
11156//----------------------------------------------------------------------------
11157
11159{
11160 QCString anchor;
11162 {
11163 MemberDef *md = toMemberDef(d);
11164 anchor=":"+md->anchor();
11165 }
11166 QCString scope;
11167 QCString fn = d->getOutputFileBase();
11170 {
11171 scope = fn;
11172 }
11173 t << "REPLACE INTO symbols (symbol_id,scope_id,name,file,line) VALUES('"
11174 << fn+anchor << "','"
11175 << scope << "','"
11176 << d->name() << "','"
11177 << d->getDefFileName() << "','"
11178 << d->getDefLine()
11179 << "');\n";
11180}
11181
11182static void dumpSymbolMap()
11183{
11184 std::ofstream f = Portable::openOutputStream("symbols.sql");
11185 if (f.is_open())
11186 {
11187 TextStream t(&f);
11188 for (const auto &[name,symList] : *Doxygen::symbolMap)
11189 {
11190 for (const auto &def : symList)
11191 {
11192 dumpSymbol(t,def);
11193 }
11194 }
11195 }
11196}
11197
11198// print developer options of Doxygen
11199static void devUsage()
11200{
11202 msg("Developer parameters:\n");
11203 msg(" -m dump symbol map\n");
11204 msg(" -b making messages output unbuffered\n");
11205 msg(" -c <file> process input file as a comment block and produce HTML output\n");
11206#if ENABLE_TRACING
11207 msg(" -t [<file|stdout|stderr>] trace debug info to file, stdout, or stderr (default file stdout)\n");
11208 msg(" -t_time [<file|stdout|stderr>] trace debug info to file, stdout, or stderr (default file stdout),\n"
11209 " and include time and thread information\n");
11210#endif
11211 msg(" -d <level> enable a debug level, such as (multiple invocations of -d are possible):\n");
11213}
11214
11215
11216//----------------------------------------------------------------------------
11217// print the version of Doxygen
11218
11219static void version(const bool extended)
11220{
11222 QCString versionString = getFullVersion();
11223 msg("{}\n",versionString);
11224 if (extended)
11225 {
11226 QCString extVers;
11227 if (!extVers.isEmpty()) extVers+= ", ";
11228 extVers += "sqlite3 ";
11229 extVers += sqlite3_libversion();
11230#if USE_LIBCLANG
11231 if (!extVers.isEmpty()) extVers+= ", ";
11232 extVers += "clang support ";
11233 extVers += CLANG_VERSION_STRING;
11234#endif
11235 if (!extVers.isEmpty())
11236 {
11237 int lastComma = extVers.findRev(',');
11238 if (lastComma != -1) extVers = extVers.replace(lastComma,1," and");
11239 msg(" with {}.\n",extVers);
11240 }
11241 }
11242}
11243
11244//----------------------------------------------------------------------------
11245// print the usage of Doxygen
11246
11247static void usage(const QCString &name,const QCString &versionString)
11248{
11250 msg("Doxygen version {0}\nCopyright Dimitri van Heesch 1997-2025\n\n"
11251 "You can use Doxygen in a number of ways:\n\n"
11252 "1) Use Doxygen to generate a template configuration file*:\n"
11253 " {1} [-s] -g [configName]\n\n"
11254 "2) Use Doxygen to update an old configuration file*:\n"
11255 " {1} [-s] -u [configName]\n\n"
11256 "3) Use Doxygen to generate documentation using an existing "
11257 "configuration file*:\n"
11258 " {1} [configName]\n\n"
11259 "4) Use Doxygen to generate a template file controlling the layout of the\n"
11260 " generated documentation:\n"
11261 " {1} -l [layoutFileName]\n\n"
11262 " In case layoutFileName is omitted DoxygenLayout.xml will be used as filename.\n"
11263 " If - is used for layoutFileName Doxygen will write to standard output.\n\n"
11264 "5) Use Doxygen to generate a template style sheet file for RTF, HTML or Latex.\n"
11265 " RTF: {1} -w rtf styleSheetFile\n"
11266 " HTML: {1}-w html headerFile footerFile styleSheetFile [configFile]\n"
11267 " LaTeX: {1} -w latex headerFile footerFile styleSheetFile [configFile]\n\n"
11268 "6) Use Doxygen to generate a rtf extensions file\n"
11269 " {1} -e rtf extensionsFile\n\n"
11270 " If - is used for extensionsFile Doxygen will write to standard output.\n\n"
11271 "7) Use Doxygen to compare the used configuration file with the template configuration file\n"
11272 " {1} -x [configFile]\n\n"
11273 " Use Doxygen to compare the used configuration file with the template configuration file\n"
11274 " without replacing the environment variables or CMake type replacement variables\n"
11275 " {1} -x_noenv [configFile]\n\n"
11276 "8) Use Doxygen to show a list of built-in emojis.\n"
11277 " {1} -f emoji outputFileName\n\n"
11278 " If - is used for outputFileName Doxygen will write to standard output.\n\n"
11279 "*) If -s is specified the comments of the configuration items in the config file will be omitted.\n"
11280 " If configName is omitted 'Doxyfile' will be used as a default.\n"
11281 " If - is used for configFile Doxygen will write / read the configuration to /from standard output / input.\n\n"
11282 "If -q is used for a Doxygen documentation run, Doxygen will see this as if QUIET=YES has been set.\n\n"
11283 "-v print version string, -V print extended version information\n"
11284 "-h,-? prints usage help information\n"
11285 "{1} -d prints additional usage flags for debugging purposes\n",versionString,name);
11286}
11287
11288//----------------------------------------------------------------------------
11289// read the argument of option 'c' from the comment argument list and
11290// update the option index 'optInd'.
11291
11292static const char *getArg(int argc,char **argv,int &optInd)
11293{
11294 char *s=nullptr;
11295 if (qstrlen(&argv[optInd][2])>0)
11296 s=&argv[optInd][2];
11297 else if (optInd+1<argc && argv[optInd+1][0]!='-')
11298 s=argv[++optInd];
11299 return s;
11300}
11301
11302//----------------------------------------------------------------------------
11303
11304/** @brief /dev/null outline parser */
11306{
11307 public:
11308 void parseInput(const QCString &/* file */, const char * /* buf */,const std::shared_ptr<Entry> &, ClangTUParser*) override {}
11309 bool needsPreprocessing(const QCString &) const override { return FALSE; }
11310 void parsePrototype(const QCString &) override {}
11311};
11312
11313
11314template<class T> std::function< std::unique_ptr<T>() > make_parser_factory()
11315{
11316 return []() { return std::make_unique<T>(); };
11317}
11318
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}
11387
11419
11420static int computeIdealCacheParam(size_t v)
11421{
11422 //printf("computeIdealCacheParam(v=%u)\n",v);
11423
11424 int r=0;
11425 while (v!=0) v>>=1,r++;
11426 // r = log2(v)
11427
11428 // convert to a valid cache size value
11429 return std::max(0,std::min(r-16,9));
11430}
11431
11432void readConfiguration(int argc, char **argv)
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}
11860
11861/** check and resolve config options */
11863{
11864 AUTO_TRACE();
11865
11870}
11871
11872/** adjust globals that depend on configuration settings. */
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}
11998
11999#ifdef HAS_SIGNALS
12000static void stopDoxygen(int)
12001{
12002 signal(SIGINT,SIG_DFL); // Re-register signal handler for default action
12003 Dir thisDir;
12004 msg("Cleaning up...\n");
12005 if (!Doxygen::filterDBFileName.isEmpty())
12006 {
12007 thisDir.remove(Doxygen::filterDBFileName.str());
12008 }
12009 killpg(0,SIGINT);
12011 exitTracing();
12012 exit(1);
12013}
12014#endif
12015
12016static void writeTagFile()
12017{
12018 QCString generateTagFile = Config_getString(GENERATE_TAGFILE);
12019 if (generateTagFile.isEmpty()) return;
12020
12021 std::ofstream f = Portable::openOutputStream(generateTagFile);
12022 if (!f.is_open())
12023 {
12024 err("cannot open tag file {} for writing\n", generateTagFile);
12025 return;
12026 }
12027 TextStream tagFile(&f);
12028 tagFile << "<?xml version='1.0' encoding='UTF-8' standalone='yes' ?>\n";
12029 tagFile << "<tagfile doxygen_version=\"" << getDoxygenVersion() << "\"";
12030 std::string gitVersion = getGitVersion();
12031 if (!gitVersion.empty())
12032 {
12033 tagFile << " doxygen_gitid=\"" << gitVersion << "\"";
12034 }
12035 tagFile << ">\n";
12036
12037 // for each file
12038 for (const auto &fn : *Doxygen::inputNameLinkedMap)
12039 {
12040 for (const auto &fd : *fn)
12041 {
12042 if (fd->isLinkableInProject()) fd->writeTagFile(tagFile);
12043 }
12044 }
12045 // for each class
12046 for (const auto &cd : *Doxygen::classLinkedMap)
12047 {
12048 ClassDefMutable *cdm = toClassDefMutable(cd.get());
12049 if (cdm && cdm->isLinkableInProject())
12050 {
12051 cdm->writeTagFile(tagFile);
12052 }
12053 }
12054 // for each concept
12055 for (const auto &cd : *Doxygen::conceptLinkedMap)
12056 {
12057 ConceptDefMutable *cdm = toConceptDefMutable(cd.get());
12058 if (cdm && cdm->isLinkableInProject())
12059 {
12060 cdm->writeTagFile(tagFile);
12061 }
12062 }
12063 // for each namespace
12064 for (const auto &nd : *Doxygen::namespaceLinkedMap)
12065 {
12067 if (ndm && nd->isLinkableInProject())
12068 {
12069 ndm->writeTagFile(tagFile);
12070 }
12071 }
12072 // for each group
12073 for (const auto &gd : *Doxygen::groupLinkedMap)
12074 {
12075 if (gd->isLinkableInProject()) gd->writeTagFile(tagFile);
12076 }
12077 // for each module
12078 for (const auto &mod : ModuleManager::instance().modules())
12079 {
12080 if (mod->isLinkableInProject()) mod->writeTagFile(tagFile);
12081 }
12082 // for each page
12083 for (const auto &pd : *Doxygen::pageLinkedMap)
12084 {
12085 if (pd->isLinkableInProject()) pd->writeTagFile(tagFile);
12086 }
12087 // for each directory
12088 for (const auto &dd : *Doxygen::dirLinkedMap)
12089 {
12090 if (dd->isLinkableInProject()) dd->writeTagFile(tagFile);
12091 }
12092 if (Doxygen::mainPage) Doxygen::mainPage->writeTagFile(tagFile);
12093
12094 tagFile << "</tagfile>\n";
12095}
12096
12097static void exitDoxygen() noexcept
12098{
12099 if (!g_successfulRun) // premature exit
12100 {
12101 Dir thisDir;
12102 msg("Exiting...\n");
12103 if (!Doxygen::filterDBFileName.isEmpty())
12104 {
12105 thisDir.remove(Doxygen::filterDBFileName.str());
12106 }
12107 }
12108}
12109
12110static QCString createOutputDirectory(const QCString &baseDirName,
12111 const QCString &formatDirName,
12112 const char *defaultDirName)
12113{
12114 QCString result = formatDirName;
12115 if (result.isEmpty())
12116 {
12117 result = baseDirName + defaultDirName;
12118 }
12119 else if (formatDirName[0]!='/' && (formatDirName.length()==1 || formatDirName[1]!=':'))
12120 {
12121 result.prepend(baseDirName+"/");
12122 }
12123 Dir formatDir(result.str());
12124 if (!formatDir.exists() && !formatDir.mkdir(result.str()))
12125 {
12126 term("Could not create output directory {}\n", result);
12127 }
12128 return result;
12129}
12130
12132{
12133 StringUnorderedSet killSet;
12134
12135 const StringVector &exclPatterns = Config_getList(EXCLUDE_PATTERNS);
12136 bool alwaysRecursive = Config_getBool(RECURSIVE);
12137 StringUnorderedSet excludeNameSet;
12138
12139 // gather names of all files in the include path
12140 g_s.begin("Searching for include files...\n");
12141 killSet.clear();
12142 const StringVector &includePathList = Config_getList(INCLUDE_PATH);
12143 for (const auto &s : includePathList)
12144 {
12145 size_t plSize = Config_getList(INCLUDE_FILE_PATTERNS).size();
12146 const StringVector &pl = plSize==0 ? Config_getList(FILE_PATTERNS) :
12147 Config_getList(INCLUDE_FILE_PATTERNS);
12148 readFileOrDirectory(s.c_str(), // s
12150 nullptr, // exclSet
12151 &pl, // patList
12152 &exclPatterns, // exclPatList
12153 nullptr, // resultList
12154 nullptr, // resultSet
12155 false, // INCLUDE_PATH isn't recursive
12156 TRUE, // errorIfNotExist
12157 &killSet); // killSet
12158 }
12159 g_s.end();
12160
12161 g_s.begin("Searching for example files...\n");
12162 killSet.clear();
12163 const StringVector &examplePathList = Config_getList(EXAMPLE_PATH);
12164 for (const auto &s : examplePathList)
12165 {
12166 readFileOrDirectory(s.c_str(), // s
12168 nullptr, // exclSet
12169 &Config_getList(EXAMPLE_PATTERNS), // patList
12170 nullptr, // exclPatList
12171 nullptr, // resultList
12172 nullptr, // resultSet
12173 (alwaysRecursive || Config_getBool(EXAMPLE_RECURSIVE)), // recursive
12174 TRUE, // errorIfNotExist
12175 &killSet); // killSet
12176 }
12177 g_s.end();
12178
12179 g_s.begin("Searching for images...\n");
12180 killSet.clear();
12181 const StringVector &imagePathList=Config_getList(IMAGE_PATH);
12182 for (const auto &s : imagePathList)
12183 {
12184 readFileOrDirectory(s.c_str(), // s
12186 nullptr, // exclSet
12187 nullptr, // patList
12188 nullptr, // exclPatList
12189 nullptr, // resultList
12190 nullptr, // resultSet
12191 alwaysRecursive, // recursive
12192 TRUE, // errorIfNotExist
12193 &killSet); // killSet
12194 }
12195 g_s.end();
12196
12197 g_s.begin("Searching for dot files...\n");
12198 killSet.clear();
12199 const StringVector &dotFileList=Config_getList(DOTFILE_DIRS);
12200 for (const auto &s : dotFileList)
12201 {
12202 readFileOrDirectory(s.c_str(), // s
12204 nullptr, // exclSet
12205 nullptr, // patList
12206 nullptr, // exclPatList
12207 nullptr, // resultList
12208 nullptr, // resultSet
12209 alwaysRecursive, // recursive
12210 TRUE, // errorIfNotExist
12211 &killSet); // killSet
12212 }
12213 g_s.end();
12214
12215 g_s.begin("Searching for msc files...\n");
12216 killSet.clear();
12217 const StringVector &mscFileList=Config_getList(MSCFILE_DIRS);
12218 for (const auto &s : mscFileList)
12219 {
12220 readFileOrDirectory(s.c_str(), // s
12222 nullptr, // exclSet
12223 nullptr, // patList
12224 nullptr, // exclPatList
12225 nullptr, // resultList
12226 nullptr, // resultSet
12227 alwaysRecursive, // recursive
12228 TRUE, // errorIfNotExist
12229 &killSet); // killSet
12230 }
12231 g_s.end();
12232
12233 g_s.begin("Searching for dia files...\n");
12234 killSet.clear();
12235 const StringVector &diaFileList=Config_getList(DIAFILE_DIRS);
12236 for (const auto &s : diaFileList)
12237 {
12238 readFileOrDirectory(s.c_str(), // s
12240 nullptr, // exclSet
12241 nullptr, // patList
12242 nullptr, // exclPatList
12243 nullptr, // resultList
12244 nullptr, // resultSet
12245 alwaysRecursive, // recursive
12246 TRUE, // errorIfNotExist
12247 &killSet); // killSet
12248 }
12249 g_s.end();
12250
12251 g_s.begin("Searching for plantuml files...\n");
12252 killSet.clear();
12253 const StringVector &plantUmlFileList=Config_getList(PLANTUMLFILE_DIRS);
12254 for (const auto &s : plantUmlFileList)
12255 {
12256 readFileOrDirectory(s.c_str(), // s
12258 nullptr, // exclSet
12259 nullptr, // patList
12260 nullptr, // exclPatList
12261 nullptr, // resultList
12262 nullptr, // resultSet
12263 alwaysRecursive, // recursive
12264 TRUE, // errorIfNotExist
12265 &killSet); // killSet
12266 }
12267 g_s.end();
12268
12269 g_s.begin("Searching for files to exclude\n");
12270 const StringVector &excludeList = Config_getList(EXCLUDE);
12271 for (const auto &s : excludeList)
12272 {
12273 readFileOrDirectory(s.c_str(), // s
12274 nullptr, // fnDict
12275 nullptr, // exclSet
12276 &Config_getList(FILE_PATTERNS), // patList
12277 nullptr, // exclPatList
12278 nullptr, // resultList
12279 &excludeNameSet, // resultSet
12280 alwaysRecursive, // recursive
12281 FALSE); // errorIfNotExist
12282 }
12283 g_s.end();
12284
12285 /**************************************************************************
12286 * Determine Input Files *
12287 **************************************************************************/
12288
12289 g_s.begin("Searching INPUT for files to process...\n");
12290 killSet.clear();
12291 Doxygen::inputPaths.clear();
12292 const StringVector &inputList=Config_getList(INPUT);
12293 for (const auto &s : inputList)
12294 {
12295 QCString path=s.c_str();
12296 size_t l = path.length();
12297 if (l>0)
12298 {
12299 // strip trailing slashes
12300 if (path.at(l-1)=='\\' || path.at(l-1)=='/') path=path.left(l-1);
12301
12303 path, // s
12305 &excludeNameSet, // exclSet
12306 &Config_getList(FILE_PATTERNS), // patList
12307 &exclPatterns, // exclPatList
12308 &g_inputFiles, // resultList
12309 nullptr, // resultSet
12310 alwaysRecursive, // recursive
12311 TRUE, // errorIfNotExist
12312 &killSet, // killSet
12313 &Doxygen::inputPaths); // paths
12314 }
12315 }
12316
12317 // Sort the FileDef objects by full path to get a predictable ordering over multiple runs
12318 std::stable_sort(Doxygen::inputNameLinkedMap->begin(),
12320 [](const auto &f1,const auto &f2)
12321 {
12322 return qstricmp_sort(f1->fullName(),f2->fullName())<0;
12323 });
12324 for (auto &fileName : *Doxygen::inputNameLinkedMap)
12325 {
12326 if (fileName->size()>1)
12327 {
12328 std::stable_sort(fileName->begin(),fileName->end(),[](const auto &f1,const auto &f2)
12329 {
12330 return qstricmp_sort(f1->absFilePath(),f2->absFilePath())<0;
12331 });
12332 }
12333 }
12334 if (Doxygen::inputNameLinkedMap->empty())
12335 {
12336 warn_uncond("No files to be processed, please check your settings, in particular INPUT, FILE_PATTERNS, and RECURSIVE\n");
12337 }
12338 g_s.end();
12339}
12340
12341
12343{
12344 if (Config_getBool(MARKDOWN_SUPPORT))
12345 {
12346 QCString mdfileAsMainPage = Config_getString(USE_MDFILE_AS_MAINPAGE);
12347 if (mdfileAsMainPage.isEmpty()) return;
12348 FileInfo fi(mdfileAsMainPage.data());
12349 if (!fi.exists())
12350 {
12351 warn_uncond("Specified markdown mainpage '{}' does not exist\n",mdfileAsMainPage);
12352 return;
12353 }
12354 bool ambig = false;
12355 if (findFileDef(Doxygen::inputNameLinkedMap,fi.absFilePath(),ambig)==nullptr)
12356 {
12357 warn_uncond("Specified markdown mainpage '{}' has not been defined as input file\n",mdfileAsMainPage);
12358 return;
12359 }
12360 }
12361}
12362
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 {
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}
13037
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}
void readAliases()
Definition aliases.cpp:170
constexpr auto prefix
Definition anchor.cpp:44
std::vector< ArgumentList > ArgumentLists
Definition arguments.h:145
This class represents an function or template argument list.
Definition arguments.h:65
RefQualifierType refQualifier() const
Definition arguments.h:116
bool noParameters() const
Definition arguments.h:117
bool pureSpecifier() const
Definition arguments.h:113
iterator end()
Definition arguments.h:94
void setTrailingReturnType(const QCString &s)
Definition arguments.h:122
bool hasParameters() const
Definition arguments.h:76
bool isDeleted() const
Definition arguments.h:115
QCString trailingReturnType() const
Definition arguments.h:114
size_t size() const
Definition arguments.h:100
void setPureSpecifier(bool b)
Definition arguments.h:121
bool constSpecifier() const
Definition arguments.h:111
void push_back(const Argument &a)
Definition arguments.h:102
bool empty() const
Definition arguments.h:99
void setConstSpecifier(bool b)
Definition arguments.h:119
void setRefQualifier(RefQualifierType t)
Definition arguments.h:124
void setIsDeleted(bool b)
Definition arguments.h:123
iterator begin()
Definition arguments.h:93
bool volatileSpecifier() const
Definition arguments.h:112
void setNoParameters(bool b)
Definition arguments.h:125
void setVolatileSpecifier(bool b)
Definition arguments.h:120
Definition cache.h:32
static CitationManager & instance()
Definition cite.cpp:86
void clear()
clears the database
Definition cite.cpp:112
void generatePage()
Generate the citations page.
Definition cite.cpp:333
std::unique_ptr< ClangTUParser > createTUParser(const FileDef *fd) const
static ClangParser * instance()
Returns the one and only instance of the class.
Clang parser object for a single translation unit, which consists of a source file and the directly o...
Definition clangparser.h:25
void switchToFile(const FileDef *fd)
Switches to another file within the translation unit started with start().
void parse()
Parse the file given at construction time as a translation unit This file should already be preproces...
A abstract class representing of a compound symbol.
Definition classdef.h:104
virtual const ArgumentList & templateArguments() const =0
Returns the template arguments of this class.
virtual QCString compoundTypeString() const =0
Returns the type of compound as a string.
virtual void writeDocumentation(OutputList &ol) const =0
virtual void writeMemberList(OutputList &ol) const =0
virtual bool isTemplate() const =0
Returns TRUE if this class is a template.
virtual const BaseClassList & baseClasses() const =0
Returns the list of base classes from which this class directly inherits.
virtual const MemberDef * getMemberByName(const QCString &) const =0
Returns the member with the given name.
virtual const TemplateInstanceList & getTemplateInstances() const =0
Returns a sorted dictionary with all template instances found for this template class.
virtual int isBaseClass(const ClassDef *bcd, bool followInstances, const QCString &templSpec=QCString()) const =0
Returns TRUE iff bcd is a direct or indirect base class of this class.
virtual ArgumentLists getTemplateParameterLists() const =0
Returns the template parameter lists that form the template declaration of this class.
virtual Protection protection() const =0
Return the protection level (Public,Protected,Private) in which this compound was found.
virtual MemberList * getMemberList(MemberListType lt) const =0
Returns the members in the list identified by lt.
virtual bool isForwardDeclared() const =0
Returns TRUE if this class represents a forward declaration of a template class.
virtual bool isSubClass(ClassDef *bcd, int level=0) const =0
Returns TRUE iff bcd is a direct or indirect sub class of this class.
virtual void moveTo(Definition *)=0
virtual const TemplateNameMap & getTemplateBaseClassNames() const =0
virtual bool isEmbeddedInOuterScope() const =0
virtual const MemberNameInfoLinkedMap & memberNameInfoLinkedMap() const =0
Returns a dictionary of all members.
virtual bool isImplicitTemplateInstance() const =0
virtual QCString qualifiedNameWithTemplateParameters(const ArgumentLists *actualParams=nullptr, uint32_t *actualParamIndex=nullptr) const =0
virtual std::unique_ptr< ClassDef > deepCopy(const QCString &name) const =0
virtual const ClassDef * templateMaster() const =0
Returns the template master of which this class is an instance.
CompoundType
The various compound types.
Definition classdef.h:109
@ Singleton
Definition classdef.h:117
@ Interface
Definition classdef.h:112
@ Exception
Definition classdef.h:115
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e.
virtual bool containsOverload(const MemberDef *md) const =0
virtual ClassLinkedRefMap getClasses() const =0
returns the classes nested into this class
virtual FileDef * getFileDef() const =0
Returns the namespace this compound is in, or 0 if it has a global scope.
virtual QCString requiresClause() const =0
virtual void writeTagFile(TextStream &) const =0
virtual void writeDocumentationForInnerClasses(OutputList &ol) const =0
virtual void computeAnchors()=0
virtual void addTypeConstraints()=0
virtual void overrideCollaborationGraph(bool e)=0
virtual void setClassName(const QCString &name)=0
virtual void countMembers()=0
virtual void addMembersToMemberGroup()=0
virtual void makeTemplateArgument(bool b=TRUE)=0
virtual void setTemplateBaseClassNames(const TemplateNameMap &templateNames)=0
virtual void insertExplicitTemplateInstance(ClassDef *instance, const QCString &spec)=0
virtual void setMetaData(const QCString &md)=0
virtual void setFileDef(FileDef *fd)=0
virtual void addUsedClass(ClassDef *cd, const QCString &accessName, Protection prot)=0
virtual void reclassifyMember(MemberDefMutable *md, MemberType t)=0
virtual ClassDef * insertTemplateInstance(const QCString &fileName, int startLine, int startColumn, const QCString &templSpec, bool &freshInstance)=0
virtual void insertBaseClass(ClassDef *, const QCString &name, Protection p, Specifier s, const QCString &t=QCString())=0
virtual void setTemplateArguments(const ArgumentList &al)=0
virtual void setTemplateMaster(const ClassDef *tm)=0
virtual void mergeCategory(ClassDef *category)=0
virtual void addQualifiers(const StringVector &qualifiers)=0
virtual void setClassSpecifier(TypeSpecifier spec)=0
virtual void addListReferences()=0
virtual void insertSubClass(ClassDef *, Protection p, Specifier s, const QCString &t=QCString())=0
virtual void insertUsedFile(const FileDef *)=0
virtual void setRequiresClause(const QCString &req)=0
virtual void setTagLessReference(const ClassDef *cd)=0
virtual void setUsedOnly(bool b)=0
virtual void sortMemberLists()=0
virtual void setProtection(Protection p)=0
virtual void setTypeConstraints(const ArgumentList &al)=0
virtual void overrideInheritanceGraph(CLASS_GRAPH_t e)=0
virtual void setAnonymousEnumType()=0
virtual void setCompoundType(CompoundType t)=0
virtual void distributeMemberGroupDocumentation()=0
virtual void findSectionsInDocumentation()=0
virtual void addUsedByClass(ClassDef *cd, const QCString &accessName, Protection prot)=0
virtual void insertMember(MemberDef *)=0
virtual void sortAllMembersList()=0
virtual void addMembersToTemplateInstance(const ClassDef *cd, const ArgumentList &templateArguments, const QCString &templSpec)=0
virtual void mergeMembers()=0
virtual void setIsStatic(bool b)=0
virtual void setSubGrouping(bool enabled)=0
virtual void setFileDef(FileDef *fd)=0
virtual void writeTagFile(TextStream &)=0
virtual void setInitializer(const QCString &init)=0
virtual void writeDocumentation(OutputList &ol)=0
virtual void setGroupId(int id)=0
virtual void findSectionsInDocumentation()=0
virtual void setTemplateArguments(const ArgumentList &al)=0
@ ExtCmd
Definition debug.h:36
@ Sections
Definition debug.h:48
@ Time
Definition debug.h:35
@ Qhp
Definition debug.h:44
@ Entries
Definition debug.h:47
static void printFlags()
Definition debug.cpp:137
static void clearFlag(const DebugMask mask)
Definition debug.cpp:122
static bool isFlagSet(const DebugMask mask)
Definition debug.cpp:132
static void print(DebugMask mask, int prio, fmt::format_string< Args... > fmt, Args &&... args)
Definition debug.h:76
static double elapsedTime()
Definition debug.cpp:201
static void startTimer()
Definition debug.cpp:196
static bool setFlagStr(const QCString &label)
Definition debug.cpp:103
static void setFlag(const DebugMask mask)
Definition debug.cpp:117
The common base class of all entity definitions found in the sources.
Definition definition.h:76
virtual QCString docFile() const =0
virtual const QCString & localName() const =0
virtual int getEndBodyLine() const =0
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
virtual int docLine() const =0
virtual QCString getDefFileName() const =0
virtual bool isLinkable() const =0
virtual int getDefLine() const =0
virtual DefType definitionType() const =0
virtual QCString anchor() const =0
virtual int inbodyLine() const =0
virtual const FileDef * getBodyDef() const =0
virtual int briefLine() const =0
virtual bool hasDocumentation() const =0
virtual bool isLinkableInProject() const =0
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
virtual bool isAnonymous() const =0
virtual bool isHidden() const =0
virtual const Definition * findInnerCompound(const QCString &name) const =0
virtual int getStartDefLine() const =0
virtual const GroupList & partOfGroups() const =0
virtual QCString documentation() const =0
virtual QCString qualifiedName() const =0
virtual QCString displayName(bool includeScope=TRUE) const =0
virtual bool isArtificial() const =0
virtual QCString briefFile() const =0
virtual QCString getOutputFileBase() const =0
virtual Definition * getOuterScope() const =0
virtual int getStartBodyLine() const =0
virtual int getDefColumn() const =0
virtual bool isReference() const =0
virtual QCString inbodyDocumentation() const =0
virtual QCString inbodyFile() const =0
virtual const QCString & name() const =0
virtual void mergeReferencedBy(const Definition *other)=0
virtual void setExported(bool b)=0
virtual void setBodySegment(int defLine, int bls, int ble)=0
virtual void setName(const QCString &name)=0
virtual void setHidden(bool b)=0
virtual void mergeReferences(const Definition *other)=0
virtual void setDocumentation(const QCString &d, const QCString &docFile, int docLine, bool stripWhiteSpace=TRUE)=0
virtual void setDefFile(const QCString &df, int defLine, int defColumn)=0
virtual void addInnerCompound(Definition *d)=0
virtual void addSectionsToDefinition(const std::vector< const SectionInfo * > &anchorList)=0
virtual void setInbodyDocumentation(const QCString &d, const QCString &docFile, int docLine)=0
virtual void setLanguage(SrcLangExt lang)=0
virtual void setOuterScope(Definition *d)=0
virtual void setArtificial(bool b)=0
virtual void setId(const QCString &name)=0
virtual void makePartOfGroup(GroupDef *gd)=0
virtual void setBodyDef(const FileDef *fd)=0
virtual void setBriefDescription(const QCString &b, const QCString &briefFile, int briefLine)=0
virtual void setReference(const QCString &r)=0
virtual void setRefItems(const RefItemVector &sli)=0
virtual void computeTooltip()=0
A model of a directory symbol.
Definition dirdef.h:110
virtual void overrideDirectoryGraph(bool e)=0
Class representing a directory in the file system.
Definition dir.h:75
static std::string currentDirPath()
Definition dir.cpp:342
std::string absPath() const
Definition dir.cpp:364
bool mkdir(const std::string &path, bool acceptsAbsPath=true) const
Definition dir.cpp:295
void setPath(const std::string &path)
Definition dir.cpp:229
bool remove(const std::string &path, bool acceptsAbsPath=true) const
Definition dir.cpp:314
DirIterator iterator() const
Definition dir.cpp:239
static std::string cleanDirPath(const std::string &path)
Definition dir.cpp:357
static bool setCurrent(const std::string &path)
Definition dir.cpp:350
bool exists() const
Definition dir.cpp:257
A linked map of directories.
Definition dirdef.h:173
A class that generates docset files.
Definition docsets.h:36
static void init()
bool run()
Definition dot.cpp:128
static DotManager * instance()
Definition dot.cpp:78
static NamespaceLinkedMap * namespaceLinkedMap
Definition doxygen.h:115
static ConceptLinkedMap * conceptLinkedMap
Definition doxygen.h:98
static bool suppressDocWarnings
Definition doxygen.h:132
static FileNameLinkedMap * plantUmlFileNameLinkedMap
Definition doxygen.h:110
static bool parseSourcesNeeded
Definition doxygen.h:123
static StringUnorderedSet inputPaths
Definition doxygen.h:104
static std::unique_ptr< PageDef > mainPage
Definition doxygen.h:101
static bool clangAssistedParsing
Definition doxygen.h:138
static StringUnorderedSet expandAsDefinedSet
Definition doxygen.h:119
static FileNameLinkedMap * inputNameLinkedMap
Definition doxygen.h:105
static ParserManager * parserManager
Definition doxygen.h:131
static Cache< std::string, LookupInfo > * typeLookupCache
Definition doxygen.h:127
static InputFileEncodingList inputFileEncodingList
Definition doxygen.h:140
static ClassLinkedMap * classLinkedMap
Definition doxygen.h:96
static MemberNameLinkedMap * functionNameLinkedMap
Definition doxygen.h:112
static PageLinkedMap * exampleLinkedMap
Definition doxygen.h:99
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 verifiedDotPath
Definition doxygen.h:139
static MemberGroupInfoMap memberGroupInfoMap
Definition doxygen.h:118
static QCString spaces
Definition doxygen.h:135
static IndexList * indexList
Definition doxygen.h:134
static StaticInitMap staticInitMap
Definition doxygen.h:143
static Cache< std::string, LookupInfo > * symbolLookupCache
Definition doxygen.h:128
static StringMap tagDestinationMap
Definition doxygen.h:116
static std::mutex countFlowKeywordsMutex
Definition doxygen.h:141
static ClassLinkedMap * hiddenClassLinkedMap
Definition doxygen.h:97
static FileNameLinkedMap * diaFileNameLinkedMap
Definition doxygen.h:109
static QCString htmlFileExtension
Definition doxygen.h:122
static QCString filterDBFileName
Definition doxygen.h:133
static PageLinkedMap * pageLinkedMap
Definition doxygen.h:100
static bool generatingXmlOutput
Definition doxygen.h:136
static std::unique_ptr< NamespaceDef > globalNamespaceDef
Definition doxygen.h:120
static DefinesPerFileList macroDefinitions
Definition doxygen.h:137
static DirLinkedMap * dirLinkedMap
Definition doxygen.h:129
static NamespaceAliasInfoMap namespaceAliasMap
Definition doxygen.h:113
static MemberNameLinkedMap * memberNameLinkedMap
Definition doxygen.h:111
static SymbolMap< Definition > * symbolMap
Definition doxygen.h:125
static StringUnorderedSet tagFileSet
Definition doxygen.h:117
static FileNameLinkedMap * includeNameLinkedMap
Definition doxygen.h:102
static FileNameLinkedMap * exampleNameLinkedMap
Definition doxygen.h:103
static SearchIndexIntf searchIndex
Definition doxygen.h:124
static DirRelationLinkedMap dirRelations
Definition doxygen.h:130
static std::mutex addExampleMutex
Definition doxygen.h:142
static ClangUsrMap * clangUsrMap
Definition doxygen.h:126
static GroupLinkedMap * groupLinkedMap
Definition doxygen.h:114
Generator for Eclipse help files.
Definition eclipsehelp.h:44
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
Represents an unstructured piece of information, about an entity found in the sources.
Definition entry.h:116
TextStream initializer
initial value (for variables)
Definition entry.h:197
VhdlSpecifier vhdlSpec
VHDL specifiers.
Definition entry.h:183
bool subGrouping
automatically group class members?
Definition entry.h:188
const std::vector< std::shared_ptr< Entry > > & children() const
Definition entry.h:139
bool proto
prototype ?
Definition entry.h:187
GroupDocType groupDocType
Definition entry.h:230
QCString metaData
Slice metadata.
Definition entry.h:233
int docLine
line number at which the documentation was found
Definition entry.h:201
QCString bitfields
member's bit fields
Definition entry.h:193
ArgumentList typeConstr
where clause (C#) for type constraints
Definition entry.h:215
void markAsProcessed() const
Definition entry.h:167
int endBodyLine
line number where the definition ends
Definition entry.h:218
bool exported
is the symbol exported from a C++20 module
Definition entry.h:189
const TagInfo * tagInfo() const
Definition entry.h:177
QCString includeName
include name (3 arg of \class)
Definition entry.h:199
QCString id
libclang id
Definition entry.h:231
ArgumentLists tArgLists
template argument declarations
Definition entry.h:195
LocalToc localToc
Definition entry.h:232
MethodTypes mtype
signal, slot, (dcop) method, or property?
Definition entry.h:181
@ GROUPDOC_NORMAL
defgroup
Definition entry.h:121
SrcLangExt lang
programming language in which this entry was found
Definition entry.h:227
Entry * parent() const
Definition entry.h:134
QCString inbodyDocs
documentation inside the body of a function
Definition entry.h:206
int startColumn
start column of entry in the source
Definition entry.h:225
QCString relates
related class (doc block)
Definition entry.h:209
bool explicitExternal
explicitly defined as external?
Definition entry.h:186
std::vector< const SectionInfo * > anchors
list of anchors defined in this entry
Definition entry.h:222
QCString fileName
file this entry was extracted from
Definition entry.h:223
RelatesType relatesType
how relates is handled
Definition entry.h:210
QCString write
property write accessor
Definition entry.h:212
QCString args
member argument string
Definition entry.h:192
QCString type
member type
Definition entry.h:173
std::vector< Grouping > groups
list of groups this entry belongs to
Definition entry.h:221
CommandOverrides commandOverrides
store info for commands whose default can be overridden
Definition entry.h:190
QCString exception
throw specification
Definition entry.h:214
int startLine
start line of entry in the source
Definition entry.h:224
QCString req
C++20 requires clause.
Definition entry.h:234
ArgumentList argList
member arguments as a list
Definition entry.h:194
QCString name
member name
Definition entry.h:174
QCString includeFile
include file (2 arg of \class, must be unique)
Definition entry.h:198
int inbodyLine
line number at which the body doc was found
Definition entry.h:207
EntryType section
entry type (see Sections);
Definition entry.h:172
QCString briefFile
file in which the brief desc. was found
Definition entry.h:205
int bodyLine
line number of the body in the source
Definition entry.h:216
int mGrpId
member group id
Definition entry.h:219
std::vector< BaseInfo > extends
list of base classes
Definition entry.h:220
Specifier virt
virtualness of the entry
Definition entry.h:191
std::vector< std::string > qualifiers
qualifiers specified with the qualifier command
Definition entry.h:235
QCString doc
documentation block (partly parsed)
Definition entry.h:200
QCString read
property read accessor
Definition entry.h:211
RefItemVector sli
special lists (test/todo/bug/deprecated/..) this entry is in
Definition entry.h:226
QCString docFile
file in which the documentation was found
Definition entry.h:202
Protection protection
class protection
Definition entry.h:180
bool artificial
Artificially introduced item.
Definition entry.h:229
bool hidden
does this represent an entity that is hidden from the output
Definition entry.h:228
QCString brief
brief description (doc block)
Definition entry.h:203
int briefLine
line number at which the brief desc. was found
Definition entry.h:204
FileDef * fileDef() const
Definition entry.h:169
int initLines
define/variable initializer lines to show
Definition entry.h:184
bool isStatic
static ?
Definition entry.h:185
QCString inbodyFile
file in which the body doc was found
Definition entry.h:208
TypeSpecifier spec
class/member specifiers
Definition entry.h:182
QCString inside
name of the class in which documents are found
Definition entry.h:213
Wrapper class for the Entry type.
Definition types.h:793
bool isDoc() const
Definition types.h:804
ENTRY_TYPES bool isCompound() const
Definition types.h:800
bool isFile() const
Definition types.h:802
std::string to_string() const
Definition types.h:805
bool isScope() const
Definition types.h:801
bool isCompoundDoc() const
Definition types.h:803
A class that generates a dynamic tree view side panel.
Definition ftvhelp.h:41
A model of a file symbol.
Definition filedef.h:99
virtual void addUsingDeclaration(const Definition *d)=0
virtual void removeMember(MemberDef *md)=0
virtual void insertClass(ClassDef *cd)=0
virtual void insertConcept(ConceptDef *cd)=0
virtual void overrideIncludeGraph(bool e)=0
virtual void writeSourceHeader(OutputList &ol)=0
virtual bool generateSourceFile() const =0
virtual const LinkedRefMap< NamespaceDef > & getUsedNamespaces() const =0
virtual QCString absFilePath() const =0
virtual bool isSource() const =0
virtual void parseSource(ClangTUParser *clangParser)=0
virtual void getAllIncludeFilesRecursively(StringVector &incFiles) const =0
virtual void setDiskName(const QCString &name)=0
virtual void writeSourceFooter(OutputList &ol)=0
virtual void writeSourceBody(OutputList &ol, ClangTUParser *clangParser)=0
virtual void addUsingDirective(NamespaceDef *nd)=0
virtual void overrideIncludedByGraph(bool e)=0
virtual const QCString & docName() const =0
virtual void insertMember(MemberDef *md)=0
virtual void insertNamespace(NamespaceDef *nd)=0
Minimal replacement for QFileInfo.
Definition fileinfo.h:23
std::string readLink() const
Definition fileinfo.cpp:84
bool isRelative() const
Definition fileinfo.cpp:58
bool isSymLink() const
Definition fileinfo.cpp:77
bool exists() const
Definition fileinfo.cpp:30
std::string fileName() const
Definition fileinfo.cpp:118
bool isReadable() const
Definition fileinfo.cpp:44
bool isDir() const
Definition fileinfo.cpp:70
bool isFile() const
Definition fileinfo.cpp:63
std::string dirPath(bool absPath=true) const
Definition fileinfo.cpp:137
std::string absFilePath() const
Definition fileinfo.cpp:101
Class representing all files with a certain base name.
Definition filename.h:30
Ordered dictionary of FileName objects.
Definition filename.h:73
void initFromRepository(const QCString &dir)
Definition formula.cpp:60
bool hasFormulas() const
Definition formula.cpp:720
void checkRepositories()
Definition formula.cpp:173
static FormulaManager & instance()
Definition formula.cpp:54
void generateImages(const QCString &outputDir, Format format, HighDPI hd=HighDPI::Off)
Definition formula.cpp:636
A model of a group of symbols.
Definition groupdef.h:52
virtual QCString groupTitle() const =0
virtual void overrideGroupGraph(bool e)=0
virtual bool addClass(ClassDef *def)=0
virtual bool containsFile(const FileDef *def) const =0
virtual bool addNamespace(NamespaceDef *def)=0
virtual void setGroupScope(Definition *d)=0
virtual void addFile(FileDef *def)=0
virtual MemberList * getMemberList(MemberListType lt) const =0
virtual void setGroupTitle(const QCString &newtitle)=0
virtual bool hasGroupTitle() const =0
Generator for HTML output.
Definition htmlgen.h:96
static void init()
Definition htmlgen.cpp:1160
static void writeSearchPage()
Definition htmlgen.cpp:3123
static void writeFooterFile(TextStream &t)
Definition htmlgen.cpp:1494
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
static void writeStyleSheetFile(TextStream &t)
Definition htmlgen.cpp:1482
static void writeHeaderFile(TextStream &t, const QCString &cssname)
Definition htmlgen.cpp:1488
A class that generated the HTML Help specific files.
Definition htmlhelp.h:36
static const QCString hhpFileName
Definition htmlhelp.h:89
static Index & instance()
Definition index.cpp:106
void countDataStructures()
Definition index.cpp:262
A list of index interfaces.
Definition indexlist.h:64
Generator for LaTeX output.
Definition latexgen.h:94
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 init()
Definition latexgen.cpp:633
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
void clear()
Definition linkedmap.h:212
std::unique_ptr< RefList > Ptr
Definition linkedmap.h:38
size_t size() const
Definition linkedmap.h:210
T * add(const char *k, Args &&... args)
Definition linkedmap.h:90
const T * find(const std::string &key) const
Definition linkedmap.h:47
Container class representing a vector of objects with keys.
Definition linkedmap.h:232
const T * find(const std::string &key) const
Definition linkedmap.h:243
bool empty() const
Definition linkedmap.h:374
Generator for Man page output.
Definition mangen.h:69
static void init()
Definition mangen.cpp:272
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
virtual QCString typeString() const =0
virtual QCString requiresClause() const =0
virtual bool isFriend() const =0
virtual bool isForeign() const =0
virtual QCString definition() const =0
virtual bool isRelated() const =0
virtual const ClassDef * getCachedTypedefVal() const =0
virtual QCString excpString() const =0
virtual const ClassDef * getClassDef() const =0
virtual const ArgumentList & templateArguments() const =0
virtual GroupDef * getGroupDef()=0
virtual bool isCSharpProperty() const =0
virtual bool isTypedef() const =0
virtual const MemberVector & enumFieldList() const =0
virtual void moveTo(Definition *)=0
virtual const FileDef * getFileDef() const =0
virtual const ArgumentList & argumentList() const =0
virtual bool isStrongEnumValue() const =0
virtual VhdlSpecifier getVhdlSpecifiers() const =0
virtual bool isFunction() const =0
virtual bool isExternal() const =0
virtual int getMemberGroupId() const =0
virtual bool isStatic() const =0
virtual const MemberDef * reimplements() const =0
virtual StringVector getQualifiers() const =0
virtual QCString bitfieldString() const =0
virtual bool isTypedefValCached() const =0
virtual bool isDocsForDefinition() const =0
virtual bool isDefine() const =0
virtual const NamespaceDef * getNamespaceDef() const =0
virtual bool isObjCProperty() const =0
virtual Protection protection() const =0
virtual TypeSpecifier getMemberSpecifiers() const =0
virtual bool isEnumerate() const =0
virtual MemberType memberType() const =0
virtual ClassDef * relatedAlso() const =0
virtual bool isVariable() const =0
virtual bool isStrong() const =0
virtual QCString argsString() const =0
virtual Specifier virtualness(int count=0) const =0
virtual int redefineCount() const =0
virtual int initializerLines() const =0
virtual const MemberDef * getEnumScope() const =0
virtual bool isEnumValue() const =0
virtual bool isPrototype() const =0
virtual const QCString & initializer() const =0
virtual void setMemberClass(ClassDef *cd)=0
virtual void setProtection(Protection p)=0
virtual void setMemberGroupId(int id)=0
virtual void setDocumentedEnumValues(bool value)=0
virtual void setMemberSpecifiers(TypeSpecifier s)=0
virtual void setDefinition(const QCString &d)=0
virtual ClassDefMutable * getClassDefMutable()=0
virtual void setExplicitExternal(bool b, const QCString &df, int line, int column)=0
virtual void setAccessorType(ClassDef *cd, const QCString &t)=0
virtual void setDefinitionTemplateParameterLists(const ArgumentLists &lists)=0
virtual void invalidateTypedefValCache()=0
virtual void setBitfields(const QCString &s)=0
virtual void setVhdlSpecifiers(VhdlSpecifier s)=0
virtual void setEnumScope(MemberDef *md, bool livesInsideEnum=FALSE)=0
virtual void setEnumClassScope(ClassDef *cd)=0
virtual void setMaxInitLines(int lines)=0
virtual void setInheritsDocsFrom(const MemberDef *md)=0
virtual void setRelatedAlso(ClassDef *cd)=0
virtual void setPrototype(bool p, const QCString &df, int line, int column)=0
virtual void overrideReferencesRelation(bool e)=0
virtual void makeForeign()=0
virtual void overrideReferencedByRelation(bool e)=0
virtual void setDocsForDefinition(bool b)=0
virtual void setRequiresClause(const QCString &req)=0
virtual void overrideCallGraph(bool e)=0
virtual void overrideInlineSource(bool e)=0
virtual void setArgsString(const QCString &as)=0
virtual void setInitializer(const QCString &i)=0
virtual void copyArgumentNames(const MemberDef *bmd)=0
virtual void overrideEnumValues(bool e)=0
virtual void mergeMemberSpecifiers(TypeSpecifier s)=0
virtual void addQualifiers(const StringVector &qualifiers)=0
virtual void insertEnumField(MemberDef *md)=0
virtual void moveDeclArgumentList(std::unique_ptr< ArgumentList > al)=0
virtual void overrideCallerGraph(bool e)=0
virtual void setReimplements(MemberDef *md)=0
virtual void setDeclFile(const QCString &df, int line, int column)=0
virtual void invalidateCachedArgumentTypes()=0
virtual void moveArgumentList(std::unique_ptr< ArgumentList > al)=0
virtual void makeRelated()=0
virtual void insertReimplementedBy(MemberDef *md)=0
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:125
Ptr & front()
Definition membername.h:51
size_t size() const
Definition membername.h:48
iterator begin()
Definition membername.h:37
iterator end()
Definition membername.h:38
void push_back(Ptr &&p)
Definition membername.h:54
Ordered dictionary of MemberName objects.
Definition membername.h:63
const MemberDef * find(const QCString &name) const
Definition memberlist.h:93
const MemberDef * findRev(const QCString &name) const
Definition memberlist.h:106
void addListReferences()
void sortMemberLists()
static ModuleManager & instance()
void addDocs(const Entry *root)
void addConceptToModule(const Entry *root, ConceptDef *cd)
void addClassToModule(const Entry *root, ClassDef *cd)
void addMemberToModule(const Entry *root, MemberDef *md)
void writeDocumentation(OutputList &ol)
void addMembersToMemberGroup()
void findSectionsInDocumentation()
void distributeMemberGroupDocumentation()
An abstract interface of a namespace symbol.
virtual const LinkedRefMap< NamespaceDef > & getUsedNamespaces() const =0
virtual bool isInline() const =0
virtual void insertUsedFile(FileDef *fd)=0
virtual void setMetaData(const QCString &m)=0
virtual void findSectionsInDocumentation()=0
virtual void countMembers()=0
virtual void addUsingDirective(NamespaceDef *nd)=0
virtual void insertMember(MemberDef *md)=0
virtual void addUsingDeclaration(const Definition *d)=0
virtual void distributeMemberGroupDocumentation()=0
virtual void writeTagFile(TextStream &)=0
virtual void addListReferences()=0
virtual void writeDocumentation(OutputList &ol)=0
virtual void setInline(bool isInline)=0
virtual void computeAnchors()=0
virtual void combineUsingRelations(NamespaceDefSet &visitedNamespace)=0
virtual void setFileName(const QCString &fn)=0
virtual void sortMemberLists()=0
virtual void addMembersToMemberGroup()=0
/dev/null outline parser
bool needsPreprocessing(const QCString &) const override
Returns TRUE if the language identified by extension needs the C preprocessor to be run before feed t...
void parseInput(const QCString &, const char *, const std::shared_ptr< Entry > &, ClangTUParser *) override
Parses a single input file with the goal to build an Entry tree.
void parsePrototype(const QCString &) override
Callback function called by the comment block scanner.
Abstract interface for outline parsers.
Definition parserintf.h:42
virtual bool needsPreprocessing(const QCString &extension) const =0
Returns TRUE if the language identified by extension needs the C preprocessor to be run before feed t...
virtual void parseInput(const QCString &fileName, const char *fileBuf, const std::shared_ptr< Entry > &root, ClangTUParser *clangParser)=0
Parses a single input file with the goal to build an Entry tree.
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:314
A model of a page symbol.
Definition pagedef.h:26
virtual void setLocalToc(const LocalToc &tl)=0
virtual void setFileName(const QCString &name)=0
virtual void setShowLineNo(bool)=0
virtual void setPageScope(Definition *)=0
virtual const GroupDef * getGroupDef() const =0
Manages programming language parsers.
Definition parserintf.h:147
static PlantumlManager & instance()
Definition plantuml.cpp:231
void run()
Run plant UML tool for all images.
Definition plantuml.cpp:389
void processFile(const QCString &fileName, const std::string &input, std::string &output)
Definition pre.l:4012
void addSearchDir(const QCString &dir)
Definition pre.l:3994
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
void fill(char c, int len=-1)
Fills a string with a predefined character.
Definition qcstring.h:180
QCString & prepend(const char *s)
Definition qcstring.h:407
int toInt(bool *ok=nullptr, int base=10) const
Definition qcstring.cpp:249
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:153
bool startsWith(const char *s) const
Definition qcstring.h:492
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 endsWith(const char *s) const
Definition qcstring.h:509
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:578
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 std::string & str() const
Definition qcstring.h:537
QCString & setNum(short n)
Definition qcstring.h:444
QCString right(size_t len) const
Definition qcstring.h:219
size_t size() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:156
QCString & sprintf(const char *format,...)
Definition qcstring.cpp:29
@ ExplicitSize
Definition qcstring.h:133
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition qcstring.cpp:91
QCString & replace(size_t index, size_t len, const char *s)
Definition qcstring.cpp:212
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
int contains(char c, bool cs=TRUE) const
Definition qcstring.cpp:143
bool stripPrefix(const QCString &prefix)
Definition qcstring.h:198
void clear()
Definition qcstring.h:169
Definition qhp.h:27
static const QCString qhpFileName
Definition qhp.h:47
static QCString getQchFileName()
Definition qhp.cpp:426
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
static void writeStyleSheetFile(TextStream &t)
Definition rtfgen.cpp:394
static void writeExtensionsFile(TextStream &t)
Definition rtfgen.cpp:409
static RefListManager & instance()
Definition reflist.h:121
Abstract proxy interface for non-javascript based search indices.
class that provide information about a section.
Definition section.h:57
QCString ref() const
Definition section.h:71
QCString fileName() const
Definition section.h:73
int lineNr() const
Definition section.h:72
SectionInfo * replace(const QCString &label, const QCString &fileName, int lineNr, const QCString &title, SectionType type, int level, const QCString &ref=QCString())
Definition section.h:156
SectionInfo * add(const SectionInfo &si)
Definition section.h:138
static SectionManager & instance()
returns a reference to the singleton
Definition section.h:178
static constexpr int Page
Definition section.h:31
std::vector< stat > stats
Definition doxygen.cpp:268
void print()
Definition doxygen.cpp:245
void begin(const char *name)
Definition doxygen.cpp:232
void end()
Definition doxygen.cpp:238
std::chrono::steady_clock::time_point startTime
Definition doxygen.cpp:269
const Definition * resolveSymbol(const Definition *scope, const QCString &name, const QCString &args=QCString(), bool checkCV=false, bool insideCode=false, bool onlyLinkable=false)
Find the symbool definition matching name within the scope set.
const ClassDef * resolveClass(const Definition *scope, const QCString &name, bool maybeUnlinkable=false, bool mayBeHidden=false)
Find the class definition matching name within the scope set.
QCString getTemplateSpec() const
In case a call to resolveClass() points to a template specialization, the template part is return via...
ClassDefMutable * resolveClassMutable(const Definition *scope, const QCString &name, bool mayBeUnlinkable=false, bool mayBeHidden=false)
Wrapper around resolveClass that returns a mutable interface to the class object or a nullptr if the ...
const MemberDef * getTypedef() const
In case a call to resolveClass() resolves to a type member (e.g.
Text streaming class that buffers data.
Definition textstream.h:36
std::string str() const
Return the contents of the buffer as a std::string object.
Definition textstream.h:229
Class managing a pool of worker threads.
Definition threadpool.h:48
auto queue(F &&f, Args &&... args) -> std::future< decltype(f(args...))>
Queue the callable function f for the threads to execute.
Definition threadpool.h:77
Wrapper class for a number of boolean properties.
Definition types.h:654
std::string to_string() const
Definition types.h:682
static void correctMemberProperties(MemberDefMutable *md)
static void computeVhdlComponentRelations()
ClassDefMutable * toClassDefMutable(Definition *d)
ClassDef * getClass(const QCString &n)
std::unique_ptr< ClassDef > createClassDefAlias(const Definition *newScope, const ClassDef *cd)
Definition classdef.cpp:788
std::unique_ptr< ClassDef > createClassDef(const QCString &fileName, int startLine, int startColumn, const QCString &name, ClassDef::CompoundType ct, const QCString &ref, const QCString &fName, bool isSymbol, bool isJavaEnum)
Factory method to create a new ClassDef object.
Definition classdef.cpp:559
ClassDef * toClassDef(Definition *d)
std::unordered_set< const ClassDef * > ClassDefSet
Definition classdef.h:95
std::map< std::string, int > TemplateNameMap
Definition classdef.h:93
ClassDefMutable * getClassMutable(const QCString &key)
Definition classdef.h:469
Class representing a regular expression.
Definition regex.h:39
Class to iterate through matches.
Definition regex.h:232
Object representing the matching results.
Definition regex.h:153
First pass comment processing.
void convertCppComments(const std::string &inBuf, std::string &outBuf, const std::string &fn)
Converts the comments in a file.
ConceptDefMutable * toConceptDefMutable(Definition *d)
std::unique_ptr< ConceptDef > createConceptDef(const QCString &fileName, int startLine, int startColumn, const QCString &name, const QCString &tagRef, const QCString &tagFile)
ConceptDefMutable * getConceptMutable(const QCString &key)
Definition conceptdef.h:90
#define Config_getInt(name)
Definition config.h:34
#define Config_getList(name)
Definition config.h:38
#define Config_updateString(name, value)
Definition config.h:39
#define Config_updateBool(name, value)
Definition config.h:40
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
#define Config_updateList(name,...)
Definition config.h:43
#define Config_getEnum(name)
Definition config.h:35
std::set< std::string > StringSet
Definition containers.h:31
std::unordered_set< std::string > StringUnorderedSet
Definition containers.h:29
std::map< std::string, std::string > StringMap
Definition containers.h:30
std::vector< std::string > StringVector
Definition containers.h:33
void parseFuncDecl(const QCString &decl, const SrcLangExt lang, QCString &clName, QCString &type, QCString &name, QCString &args, QCString &funcTempList, QCString &exceptions)
Definition declinfo.l:325
std::unique_ptr< ArgumentList > stringToArgumentList(SrcLangExt lang, const QCString &argsString, QCString *extraTypeChars=nullptr)
Definition defargs.l:814
void generateDEF()
Definition defgen.cpp:482
std::unordered_map< std::string, DefineList > DefinesPerFileList
Definition define.h:50
Definition * toDefinition(DefinitionMutable *dm)
DefinitionMutable * toDefinitionMutable(Definition *d)
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
void generateDirDocs(OutputList &ol)
Definition dirdef.cpp:1176
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:47
#define AUTO_TRACE(...)
Definition docnode.cpp:46
#define AUTO_TRACE_EXIT(...)
Definition docnode.cpp:48
constexpr DocNodeVariant * parent(DocNodeVariant *n)
returns the parent node of a given node n or nullptr if the node has no parent.
Definition docnode.h:1330
static void findInheritedTemplateInstances()
Definition doxygen.cpp:5245
void printNavTree(Entry *root, int indent)
Definition doxygen.cpp:9917
static void addClassToContext(const Entry *root)
Definition doxygen.cpp:931
static void makeTemplateInstanceRelation(const Entry *root, ClassDefMutable *cd)
Definition doxygen.cpp:5260
static StringUnorderedSet g_pathsVisited(1009)
static int findEndOfTemplate(const QCString &s, size_t startPos)
Definition doxygen.cpp:3031
static void buildGroupList(const Entry *root)
Definition doxygen.cpp:425
static void insertMemberAlias(Definition *outerScope, const MemberDef *md)
Definition doxygen.cpp:6602
static void findUsingDeclarations(const Entry *root, bool filterPythonPackages)
Definition doxygen.cpp:2005
static void flushCachedTemplateRelations()
Definition doxygen.cpp:9344
static bool isRecursiveBaseClass(const QCString &scope, const QCString &name)
Definition doxygen.cpp:4803
static void copyLatexStyleSheet()
static void generateDocsForClassList(const std::vector< ClassDefMutable * > &classList)
Definition doxygen.cpp:9004
static std::shared_ptr< Entry > parseFile(OutlineParserInterface &parser, FileDef *fd, const QCString &fn, ClangTUParser *clangParser, bool newTU)
static int findFunctionPtr(const std::string &type, SrcLangExt lang, int *pLength=nullptr)
Definition doxygen.cpp:2827
static bool isSpecialization(const ArgumentLists &srcTempArgLists, const ArgumentLists &dstTempArgLists)
Definition doxygen.cpp:5918
static MemberDef * addVariableToClass(const Entry *root, ClassDefMutable *cd, MemberType mtype, const QCString &type, const QCString &name, const QCString &args, bool fromAnnScope, MemberDef *fromAnnMemb, Protection prot, Relationship related)
Definition doxygen.cpp:2425
static void computeTemplateClassRelations()
Definition doxygen.cpp:5339
static std::string resolveSymlink(const std::string &path)
void adjustConfiguration()
adjust globals that depend on configuration settings.
static void findDEV(const MemberNameLinkedMap &mnsd)
Definition doxygen.cpp:8058
static void runQHelpGenerator()
static void addConceptToContext(const Entry *root)
Definition doxygen.cpp:1151
static void addRelatedPage(Entry *root)
Definition doxygen.cpp:328
void initDoxygen()
static void addIncludeFile(DefMutable *cd, FileDef *ifd, const Entry *root)
Definition doxygen.cpp:581
static StringVector g_inputFiles
Definition doxygen.cpp:187
void printSectionsTree()
Definition doxygen.cpp:9940
class Statistics g_s
static void createUsingMemberImportForClass(const Entry *root, ClassDefMutable *cd, const MemberDef *md, const QCString &fileName, const QCString &memName)
Definition doxygen.cpp:2109
static void generateXRefPages()
Definition doxygen.cpp:5511
static void findUsingDeclImports(const Entry *root)
Definition doxygen.cpp:2158
static void copyStyleSheet()
FindBaseClassRelation_Mode
Definition doxygen.cpp:285
@ Undocumented
Definition doxygen.cpp:288
@ TemplateInstances
Definition doxygen.cpp:286
@ DocumentedOnly
Definition doxygen.cpp:287
void distributeClassGroupRelations()
Definition doxygen.cpp:1446
static void generateGroupDocs()
static void findDirDocumentation(const Entry *root)
Definition doxygen.cpp:9581
void checkConfiguration()
check and resolve config options
QCString stripTemplateSpecifiers(const QCString &s)
Definition doxygen.cpp:678
static bool findClassRelation(const Entry *root, Definition *context, ClassDefMutable *cd, const BaseInfo *bi, const TemplateNameMap &templateNames, FindBaseClassRelation_Mode mode, bool isArtificial)
Definition doxygen.cpp:4845
static void resolveTemplateInstanceInType(const Entry *root, const Definition *scope, const MemberDef *md)
Definition doxygen.cpp:4773
static void organizeSubGroupsFiltered(const Entry *root, bool additional)
Definition doxygen.cpp:465
static void warnUndocumentedNamespaces()
Definition doxygen.cpp:5294
static TemplateNameMap getTemplateArgumentsInName(const ArgumentList &templateArguments, const std::string &name)
Definition doxygen.cpp:4450
static NamespaceDef * findUsedNamespace(const LinkedRefMap< NamespaceDef > &unl, const QCString &name)
Definition doxygen.cpp:1837
static void buildConceptList(const Entry *root)
Definition doxygen.cpp:1276
static void resolveClassNestingRelations()
Definition doxygen.cpp:1331
static void generateNamespaceConceptDocs(const ConceptLinkedRefMap &conceptList)
static void findMember(const Entry *root, const QCString &relates, const QCString &type, const QCString &args, QCString funcDecl, bool overloaded, bool isFunc)
Definition doxygen.cpp:6645
static void findClassEntries(const Entry *root)
Definition doxygen.cpp:5208
static void processTagLessClasses(const ClassDef *rootCd, const ClassDef *cd, ClassDefMutable *tagParentCd, const QCString &prefix, int count)
Look through the members of class cd and its public members.
Definition doxygen.cpp:1565
static void addMemberFunction(const Entry *root, MemberName *mn, const QCString &scopeName, const QCString &namespaceName, const QCString &className, const QCString &funcTyp, const QCString &funcName, const QCString &funcArgs, const QCString &funcTempList, const QCString &exceptions, const QCString &type, const QCString &args, bool isFriend, TypeSpecifier spec, const QCString &relates, const QCString &funcDecl, bool overloaded, bool isFunc)
Definition doxygen.cpp:6129
static void vhdlCorrectMemberProperties()
Definition doxygen.cpp:8302
static void generateExampleDocs()
Definition doxygen.cpp:9956
void generateOutput()
static void stopDoxygen(int)
static void findTemplateInstanceRelation(const Entry *root, Definition *context, ClassDefMutable *templateClass, const QCString &templSpec, const TemplateNameMap &templateNames, bool isArtificial)
Definition doxygen.cpp:4722
static void substituteTemplatesInArgList(const ArgumentLists &srcTempArgLists, const ArgumentLists &dstTempArgLists, const ArgumentList &src, ArgumentList &dst)
Definition doxygen.cpp:6032
static void computeMemberReferences()
Definition doxygen.cpp:5408
static void generateConfigFile(const QCString &configFile, bool shortList, bool updateOnly=FALSE)
static void transferRelatedFunctionDocumentation()
Definition doxygen.cpp:4364
static void addMembersToMemberGroup()
Definition doxygen.cpp:9209
static bool tryAddEnumDocsToGroupMember(const Entry *root, const QCString &name)
Definition doxygen.cpp:7939
static void addOverloaded(const Entry *root, MemberName *mn, const QCString &funcType, const QCString &funcName, const QCString &funcArgs, const QCString &funcDecl, const QCString &exceptions, TypeSpecifier spec)
Definition doxygen.cpp:6535
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 dumpSymbolMap()
static void buildTypedefList(const Entry *root)
Definition doxygen.cpp:3354
static void findGroupScope(const Entry *root)
Definition doxygen.cpp:440
static void generateFileDocs()
Definition doxygen.cpp:8667
static void findDefineDocumentation(Entry *root)
Definition doxygen.cpp:9495
static void findUsedClassesForClass(const Entry *root, Definition *context, ClassDefMutable *masterCd, ClassDefMutable *instanceCd, bool isArtificial, const ArgumentList *actualArgs=nullptr, const TemplateNameMap &templateNames=TemplateNameMap())
Definition doxygen.cpp:4513
void parseInput()
static void findMemberDocumentation(const Entry *root)
Definition doxygen.cpp:7415
static void copyIcon(const QCString &outputOption)
static void addLocalObjCMethod(const Entry *root, const QCString &scopeName, const QCString &funcType, const QCString &funcName, const QCString &funcArgs, const QCString &exceptions, const QCString &funcDecl, TypeSpecifier spec)
Definition doxygen.cpp:6076
static bool findGlobalMember(const Entry *root, const QCString &namespaceName, const QCString &type, const QCString &name, const QCString &tempArg, const QCString &, const QCString &decl, TypeSpecifier)
Definition doxygen.cpp:5711
static void distributeMemberGroupDocumentation()
Definition doxygen.cpp:9247
static void generateNamespaceClassDocs(const ClassLinkedRefMap &classList)
static void addEnumValuesToEnums(const Entry *root)
Definition doxygen.cpp:7648
static void generatePageDocs()
Definition doxygen.cpp:9871
static void resolveUserReferences()
Definition doxygen.cpp:9803
static void compareDoxyfile(Config::CompareMode diffList)
static void addPageToContext(PageDef *pd, Entry *root)
Definition doxygen.cpp:309
static void buildVarList(const Entry *root)
Definition doxygen.cpp:3490
static void buildSequenceList(const Entry *root)
Definition doxygen.cpp:3453
static void generateFileSources()
Definition doxygen.cpp:8501
static QCString substituteTemplatesInString(const ArgumentLists &srcTempArgLists, const ArgumentLists &dstTempArgLists, const std::string &src)
Definition doxygen.cpp:5948
static void copyLogo(const QCString &outputOption)
static void usage(const QCString &name, const QCString &versionString)
static MemberDef * addVariableToFile(const Entry *root, MemberType mtype, const QCString &scope, const QCString &type, const QCString &name, const QCString &args, bool fromAnnScope, MemberDef *fromAnnMemb)
Definition doxygen.cpp:2586
static void generateClassDocs()
Definition doxygen.cpp:9102
static void buildNamespaceList(const Entry *root)
Definition doxygen.cpp:1670
static int computeIdealCacheParam(size_t v)
static void readTagFile(const std::shared_ptr< Entry > &root, const QCString &tagLine)
static void findIncludedUsingDirectives()
Definition doxygen.cpp:2408
static void addDefineDoc(const Entry *root, MemberDefMutable *md)
Definition doxygen.cpp:9470
static void addMemberDocs(const Entry *root, MemberDefMutable *md, const QCString &funcDecl, const ArgumentList *al, bool over_load, TypeSpecifier spec)
Definition doxygen.cpp:5525
static void countMembers()
Definition doxygen.cpp:8963
void clearAll()
Definition doxygen.cpp:201
static void devUsage()
static void addInterfaceOrServiceToServiceOrSingleton(const Entry *root, ClassDefMutable *cd, QCString const &rname)
Definition doxygen.cpp:3522
static void organizeSubGroups(const Entry *root)
Definition doxygen.cpp:484
static void applyMemberOverrideOptions(const Entry *root, MemberDefMutable *md)
Definition doxygen.cpp:2097
void searchInputFiles()
static void findFriends()
Definition doxygen.cpp:4186
static void findEnums(const Entry *root)
Definition doxygen.cpp:7473
static void dumpSymbol(TextStream &t, Definition *d)
static void addClassAndNestedClasses(std::vector< ClassDefMutable * > &list, ClassDefMutable *cd)
Definition doxygen.cpp:9079
static void addEnumDocs(const Entry *root, MemberDefMutable *md)
Definition doxygen.cpp:7898
static void addListReferences()
Definition doxygen.cpp:5442
static void exitDoxygen() noexcept
static void copyExtraFiles(const StringVector &files, const QCString &filesOption, const QCString &outputOption)
static bool isClassSection(const Entry *root)
Definition doxygen.cpp:5186
static Definition * findScopeFromQualifiedName(NamespaceDefMutable *startScope, const QCString &n, FileDef *fileScope, const TagInfo *tagInfo)
Definition doxygen.cpp:774
static ClassDef * findClassWithinClassContext(Definition *context, ClassDef *cd, const QCString &name)
Definition doxygen.cpp:4478
static void buildGroupListFiltered(const Entry *root, bool additional, bool includeExternal)
Definition doxygen.cpp:356
static void runHtmlHelpCompiler()
static QCString extractClassName(const Entry *root)
Definition doxygen.cpp:5217
static void addMembersToIndex()
Definition doxygen.cpp:8092
static bool g_dumpSymbolMap
Definition doxygen.cpp:191
static void version(const bool extended)
static void addGlobalFunction(const Entry *root, const QCString &rname, const QCString &sc)
Definition doxygen.cpp:3772
static OutputList * g_outputList
Definition doxygen.cpp:188
static void findMainPage(Entry *root)
Definition doxygen.cpp:9671
static ClassDef::CompoundType convertToCompoundType(EntryType section, TypeSpecifier specifier)
Definition doxygen.cpp:889
static void findUsingDirectives(const Entry *root)
Definition doxygen.cpp:1850
std::unique_ptr< ArgumentList > getTemplateArgumentsFromName(const QCString &name, const ArgumentLists &tArgLists)
Definition doxygen.cpp:859
static bool g_successfulRun
Definition doxygen.cpp:190
static void addSourceReferences()
Definition doxygen.cpp:8727
std::function< std::unique_ptr< T >() > make_parser_factory()
static void buildExampleList(Entry *root)
Definition doxygen.cpp:9888
static void inheritDocumentation()
Definition doxygen.cpp:9149
static void flushUnresolvedRelations()
Definition doxygen.cpp:9398
static bool isSymbolHidden(const Definition *d)
Definition doxygen.cpp:8896
void readConfiguration(int argc, char **argv)
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)
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 void filterMemberDocumentation(const Entry *root, const QCString &relates)
Definition doxygen.cpp:7265
static QCString createOutputDirectory(const QCString &baseDirName, const QCString &formatDirName, const char *defaultDirName)
void initResources()
static bool isVarWithConstructor(const Entry *root)
Definition doxygen.cpp:2887
static StringSet g_usingDeclarations
Definition doxygen.cpp:189
static void buildDictionaryList(const Entry *root)
Definition doxygen.cpp:3471
static bool haveEqualFileNames(const Entry *root, const MemberDef *md)
Definition doxygen.cpp:9457
static void generateNamespaceDocs()
static void buildClassDocList(const Entry *root)
Definition doxygen.cpp:1137
static void buildPageList(Entry *root)
Definition doxygen.cpp:9644
static void writeTagFile()
static Definition * buildScopeFromQualifiedName(const QCString &name_, SrcLangExt lang, const TagInfo *tagInfo)
Definition doxygen.cpp:705
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 const StringUnorderedSet g_compoundKeywords
Definition doxygen.cpp:198
static bool scopeIsTemplate(const Definition *d)
Definition doxygen.cpp:5934
static void buildFileList(const Entry *root)
Definition doxygen.cpp:496
static ClassDefMutable * createTagLessInstance(const ClassDef *rootCd, const ClassDef *templ, const QCString &fieldName)
Definition doxygen.cpp:1479
static void buildClassList(const Entry *root)
Definition doxygen.cpp:1127
static void addMethodToClass(const Entry *root, ClassDefMutable *cd, const QCString &rtype, const QCString &rname, const QCString &rargs, bool isFriend, Protection protection, bool stat, Specifier virt, TypeSpecifier spec, const QCString &relates)
Definition doxygen.cpp:3636
static std::unique_ptr< OutlineParserInterface > getParserForFile(const QCString &fn)
static void findUsedTemplateInstances()
Definition doxygen.cpp:5278
static void computeTooltipTexts()
Definition doxygen.cpp:8903
void readFileOrDirectory(const QCString &s, FileNameLinkedMap *fnMap, StringUnorderedSet *exclSet, const StringVector *patList, const StringVector *exclPatList, StringVector *resultList, StringUnorderedSet *resultSet, bool recursive, bool errorIfNotExist, StringUnorderedSet *killSet, StringUnorderedSet *paths)
static void addVariable(const Entry *root, int isFuncPtr=-1)
Definition doxygen.cpp:3099
static void addMemberSpecialization(const Entry *root, MemberName *mn, ClassDefMutable *cd, const QCString &funcType, const QCString &funcName, const QCString &funcArgs, const QCString &funcDecl, const QCString &exceptions, TypeSpecifier spec)
Definition doxygen.cpp:6473
void cleanUpDoxygen()
static void findBaseClassesForClass(const Entry *root, Definition *context, ClassDefMutable *masterCd, ClassDefMutable *instanceCd, FindBaseClassRelation_Mode mode, bool isArtificial, const ArgumentList *actualArgs=nullptr, const TemplateNameMap &templateNames=TemplateNameMap())
Definition doxygen.cpp:4671
static void parseFilesSingleThreading(const std::shared_ptr< Entry > &root)
parse the list of input files
static void buildCompleteMemberLists()
Definition doxygen.cpp:8471
static void generateConceptDocs()
Definition doxygen.cpp:9128
static void combineUsingRelations()
Definition doxygen.cpp:9184
static const char * getArg(int argc, char **argv, int &optInd)
static const ClassDef * findClassDefinition(FileDef *fd, NamespaceDef *nd, const QCString &scopeName)
Definition doxygen.cpp:5675
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 int findTemplateSpecializationPosition(const QCString &name)
Definition doxygen.cpp:4815
static bool isEntryInGroupOfMember(const Entry *root, const MemberDef *md, bool allowNoGroup=false)
Definition doxygen.cpp:5687
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 void computeMemberRelationsForBaseClass(const ClassDef *cd, const BaseClassDef *bcd)
Definition doxygen.cpp:8334
static std::multimap< std::string, const Entry * > g_classEntries
Definition doxygen.cpp:186
std::vector< InputFileEncoding > InputFileEncodingList
Definition doxygen.h:81
std::unordered_map< std::string, BodyInfo > StaticInitMap
Definition doxygen.h:85
std::unordered_map< std::string, NamespaceAliasInfo > NamespaceAliasInfoMap
Definition doxygen.h:87
std::unordered_map< std::string, const Definition * > ClangUsrMap
Definition doxygen.h:83
std::unique_ptr< FileDef > createFileDef(const QCString &p, const QCString &n, const QCString &ref, const QCString &dn)
Definition filedef.cpp:268
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1932
std::unordered_set< const FileDef * > FileDefSet
Definition filedef.h:44
static void startScope(yyscan_t yyscanner)
start scope
void addNamespaceToGroups(const Entry *root, NamespaceDef *nd)
void addGroupToGroups(const Entry *root, GroupDef *subGroup)
void addClassToGroups(const Entry *root, ClassDef *cd)
void addDirToGroups(const Entry *root, DirDef *dd)
std::unique_ptr< GroupDef > createGroupDef(const QCString &fileName, int line, const QCString &name, const QCString &title, const QCString &refFileName)
Definition groupdef.cpp:175
void addConceptToGroups(const Entry *root, ConceptDef *cd)
void addMemberToGroups(const Entry *root, MemberDef *md)
size_t size
Definition htmlgen.cpp:156
const char * data
Definition htmlgen.cpp:158
QCString s
Definition htmlgen.cpp:154
size_t i
Definition htmlgen.cpp:161
return out get()
void startTitle(OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
Definition index.cpp:384
void endFile(OutputList &ol, bool skipNavIndex, bool skipEndContents, const QCString &navPath)
Definition index.cpp:427
void writeGraphInfo(OutputList &ol)
Definition index.cpp:4063
void endTitle(OutputList &ol, const QCString &fileName, const QCString &name)
Definition index.cpp:394
void startFile(OutputList &ol, const QCString &name, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName, int hierarchyLevel, const QCString &allMembersFile)
Definition index.cpp:401
void writeIndexHierarchy(OutputList &ol)
Definition index.cpp:5760
Translator * theTranslator
Definition language.cpp:71
void setTranslator(OUTPUT_LANGUAGE_t langName)
Definition language.cpp:73
#define LATEX_STYLE_EXTENSION
Definition latexgen.h:22
void writeDefaultLayoutFile(const QCString &fileName)
Definition layout.cpp:1732
void printLayout()
Definition layout.cpp:1820
std::unique_ptr< MemberDef > createMemberDefAlias(const Definition *newScope, const MemberDef *aliasMd)
MemberDefMutable * toMemberDefMutable(Definition *d)
void combineDeclarationAndDefinition(MemberDefMutable *mdec, MemberDefMutable *mdef)
MemberDef * toMemberDef(Definition *d)
std::unique_ptr< MemberDef > createMemberDef(const QCString &defFileName, int defLine, int defColumn, const QCString &type, const QCString &name, const QCString &args, const QCString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const QCString &metaData)
Factory method to create a new instance of a MemberDef.
std::unordered_map< int, std::unique_ptr< MemberGroupInfo > > MemberGroupInfoMap
#define DOX_NOGROUP
Definition membergroup.h:26
QCString warn_line(const QCString &file, int line)
Definition message.cpp:215
void initWarningFormat()
Definition message.cpp:237
void warn_flush()
Definition message.cpp:230
void finishWarnExit()
Definition message.cpp:295
#define warn_undoc(file, line, fmt,...)
Definition message.h:102
#define warn_uncond(fmt,...)
Definition message.h:122
#define warn(file, line, fmt,...)
Definition message.h:97
#define msg(fmt,...)
Definition message.h:94
#define err(fmt,...)
Definition message.h:127
#define term(fmt,...)
Definition message.h:137
void postProcess(bool clearHeaderAndFooter, CompareMode compareMode=CompareMode::Full)
CompareMode
Definition config.h:54
void checkAndCorrect(bool quiet, const bool check)
void compareDoxyfile(TextStream &t, CompareMode compareMode)
void deinit()
bool parse(const QCString &fileName, bool update=FALSE, CompareMode compareMode=CompareMode::Full)
void init()
void writeTemplate(TextStream &t, bool shortList, bool updateOnly=FALSE)
void updateObsolete()
void correctPath(const StringVector &list)
Correct a possible wrong PATH variable.
Definition portable.cpp:533
bool isAbsolutePath(const QCString &fileName)
Definition portable.cpp:514
FILE * popen(const QCString &name, const QCString &type)
Definition portable.cpp:496
std::ofstream openOutputStream(const QCString &name, bool append=false)
Definition portable.cpp:665
double getSysElapsedTime()
Definition portable.cpp:98
QCString pathListSeparator()
Definition portable.cpp:400
uint32_t pid()
Definition portable.cpp:265
int pclose(FILE *stream)
Definition portable.cpp:505
int system(const QCString &command, const QCString &args, bool commandHasConsole=true)
Definition portable.cpp:106
void setenv(const QCString &variable, const QCString &value)
Definition portable.cpp:303
const char * commandExtension()
Definition portable.cpp:478
QCString getenv(const QCString &variable)
Definition portable.cpp:338
void setShortDir()
Definition portable.cpp:570
QCString trunc(const QCString &s, size_t numChars=15)
Definition trace.h:56
void replaceNamespaceAliases(QCString &name)
std::unique_ptr< NamespaceDef > createNamespaceDefAlias(const Definition *newScope, const NamespaceDef *nd)
Factory method to create an alias of an existing namespace.
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.
NamespaceDef * getResolvedNamespace(const QCString &name)
NamespaceDef * toNamespaceDef(Definition *d)
NamespaceDefMutable * toNamespaceDefMutable(Definition *d)
NamespaceDefMutable * getResolvedNamespaceMutable(const QCString &key)
std::unordered_set< const NamespaceDef * > NamespaceDefSet
bool search(std::string_view str, Match &match, const Ex &re, size_t pos)
Search in a given string str starting at position pos for a match against regular expression re.
Definition regex.cpp:748
std::unique_ptr< PageDef > createPageDef(const QCString &f, int l, const QCString &n, const QCString &d, const QCString &t)
Definition pagedef.cpp:80
void generatePerlMod()
void setPerlModDoxyfile(const QCString &qs)
Portable versions of functions that are platform dependent.
int portable_iconv_close(void *cd)
void * portable_iconv_open(const char *tocode, const char *fromcode)
int qstricmp(const char *s1, const char *s2)
Definition qcstring.cpp:442
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:477
int qstricmp_sort(const char *str1, const char *str2)
Definition qcstring.h:86
const char * qPrint(const char *s)
Definition qcstring.h:672
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34
uint32_t qstrlen(const char *str)
Returns the length of string str, or 0 if a null pointer is passed.
Definition qcstring.h:58
#define ASSERT(x)
Definition qcstring.h:39
int qstrcmp(const char *str1, const char *str2)
Definition qcstring.h:69
std::vector< RefItem * > RefItemVector
Definition reflist.h:133
void initSearchIndexer()
void finalizeSearchIndexer()
static void addMemberToSearchIndex(const MemberDef *md)
void createJavaScriptSearchIndex()
void writeJavaScriptSearchIndex()
Javascript based search engine.
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 generateSqlite3()
void addSTLSupport(std::shared_ptr< Entry > &root)
Add stub entries for the most used classes in the standard template library.
Some helper functions for std::string.
void addTerminalCharIfMissing(std::string &s, char c)
Definition stringutil.h:84
This class contains the information about the argument of a function or template.
Definition arguments.h:27
QCString type
Definition arguments.h:42
QCString name
Definition arguments.h:44
QCString defval
Definition arguments.h:46
QCString array
Definition arguments.h:45
Class that contains information about an inheritance relation.
Definition classdef.h:55
ClassDef * classDef
Class definition that this relation inherits from.
Definition classdef.h:60
This class stores information about an inheritance relation.
Definition entry.h:90
Protection prot
inheritance type
Definition entry.h:95
Specifier virt
virtualness
Definition entry.h:96
QCString name
the name of the base class
Definition entry.h:94
Data associated with description found in the body.
Definition definition.h:63
Grouping info.
Definition types.h:227
QCString groupname
name of the group
Definition types.h:257
@ GROUPING_INGROUP
membership in group was defined by @ingroup
Definition types.h:236
static const char * getGroupPriName(GroupPri_t priority)
Definition types.h:240
GroupPri_t pri
priority of this definition
Definition types.h:258
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
const Definition * definition
Definition doxygen.h:60
const MemberDef * typeDef
Definition doxygen.h:61
stat(const char *n, double el)
Definition doxygen.cpp:266
const char * name
Definition doxygen.cpp:263
This struct is used to capture the tag file information for an Entry.
Definition entry.h:103
QCString fileName
Definition entry.h:105
QCString tagName
Definition entry.h:104
void parseTagFile(const std::shared_ptr< Entry > &root, const char *fullName)
void exitTracing()
Definition trace.cpp:52
void initTracing(const QCString &logFile, bool timing)
Definition trace.cpp:22
#define TRACE(...)
Definition trace.h:77
MemberType
Definition types.h:552
@ Enumeration
Definition types.h:557
@ EnumValue
Definition types.h:558
@ Dictionary
Definition types.h:568
@ Interface
Definition types.h:565
@ Sequence
Definition types.h:567
@ Variable
Definition types.h:555
@ Property
Definition types.h:563
@ Typedef
Definition types.h:556
@ Function
Definition types.h:554
@ Service
Definition types.h:566
Protection
Definition types.h:32
SrcLangExt
Definition types.h:207
Relationship
Definition types.h:167
Specifier
Definition types.h:80
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:579
QCString mergeScopes(const QCString &leftScope, const QCString &rightScope)
Definition util.cpp:5094
QCString normalizeNonTemplateArgumentsInString(const QCString &name, const Definition *context, const ArgumentList &formalArgs)
Definition util.cpp:4800
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5719
bool protectionLevelVisible(Protection prot)
Definition util.cpp:6451
bool matchTemplateArguments(const ArgumentList &srcAl, const ArgumentList &dstAl)
Definition util.cpp:2197
void addCodeOnlyMappings()
Definition util.cpp:5713
QCString substituteTemplateArgumentsInString(const QCString &nm, const ArgumentList &formalArgs, const ArgumentList *actualArgs)
Definition util.cpp:4865
int extractClassNameFromType(const QCString &type, int &pos, QCString &name, QCString &templSpec, SrcLangExt lang)
Definition util.cpp:4726
bool leftScopeMatch(const QCString &scope, const QCString &name)
Definition util.cpp:893
QCString stripAnonymousNamespaceScope(const QCString &s)
Definition util.cpp:242
QCString stripFromIncludePath(const QCString &path)
Definition util.cpp:341
bool checkIfTypedef(const Definition *scope, const FileDef *fileScope, const QCString &n)
Definition util.cpp:5823
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
bool patternMatch(const FileInfo &fi, const StringVector &patList)
Definition util.cpp:6202
bool openOutputFile(const QCString &outFile, std::ofstream &f)
Definition util.cpp:6808
QCString tempArgListToString(const ArgumentList &al, SrcLangExt lang, bool includeDefault)
Definition util.cpp:1247
void addRefItem(const RefItemVector &sli, const QCString &key, const QCString &prefix, const QCString &name, const QCString &title, const QCString &args, const Definition *scope)
Definition util.cpp:5316
QCString showFileDefMatches(const FileNameLinkedMap *fnMap, const QCString &n)
Definition util.cpp:3543
QCString fileToString(const QCString &name, bool filter, bool isSourceCode)
Definition util.cpp:1442
QCString filterTitle(const QCString &title)
Definition util.cpp:6128
QCString removeAnonymousScopes(const QCString &str)
Definition util.cpp:173
bool matchArguments2(const Definition *srcScope, const FileDef *srcFileScope, const ArgumentList *srcAl, const Definition *dstScope, const FileDef *dstFileScope, const ArgumentList *dstAl, bool checkCV, SrcLangExt lang)
Definition util.cpp:1959
QCString resolveTypeDef(const Definition *context, const QCString &qualifiedName, const Definition **typedefContext)
Definition util.cpp:385
bool checkExtension(const QCString &fName, const QCString &ext)
Definition util.cpp:5408
int computeQualifiedIndex(const QCString &name)
Return the index of the last :: in the string name that is still before the first <.
Definition util.cpp:7336
void initDefaultExtensionMapping()
Definition util.cpp:5646
bool findAndRemoveWord(QCString &sentence, const char *word)
removes occurrences of whole word from sentence, while keeps internal spaces and reducing multiple se...
Definition util.cpp:5495
QCString convertNameToFile(const QCString &name, bool allowDots, bool allowUnderscore)
Definition util.cpp:4018
QCString langToString(SrcLangExt lang)
Returns a string representation of lang.
Definition util.cpp:6405
EntryType guessSection(const QCString &name)
Definition util.cpp:350
void extractNamespaceName(const QCString &scopeName, QCString &className, QCString &namespaceName, bool allowEmptyClass)
Definition util.cpp:4211
QCString argListToString(const ArgumentList &al, bool useCanonicalType, bool showDefVals)
Definition util.cpp:1202
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:6411
void mergeMemberOverrideOptions(MemberDefMutable *md1, MemberDefMutable *md2)
Definition util.cpp:7373
QCString mangleCSharpGenericName(const QCString &name)
Definition util.cpp:7425
QCString projectLogoFile()
Definition util.cpp:3659
void mergeArguments(ArgumentList &srcAl, ArgumentList &dstAl, bool forceNameOverwrite)
Definition util.cpp:2053
bool copyFile(const QCString &src, const QCString &dest)
Copies the contents of file with name src to the newly created file with name dest.
Definition util.cpp:6371
QCString stripTemplateSpecifiersFromScope(const QCString &fullName, bool parentOnly, QCString *pLastScopeStripped, QCString scopeName, bool allowArtificial)
Definition util.cpp:5027
QCString getOverloadDocs()
Definition util.cpp:4600
int getPrefixIndex(const QCString &name)
Definition util.cpp:3750
bool rightScopeMatch(const QCString &scope, const QCString &name)
Definition util.cpp:882
bool updateLanguageMapping(const QCString &extension, const QCString &language)
Definition util.cpp:5614
QCString getFileNameExtension(const QCString &fn)
Definition util.cpp:5761
QCString replaceAnonymousScopes(const QCString &s, const QCString &replacement)
Definition util.cpp:230
FileDef * findFileDef(const FileNameLinkedMap *fnMap, const QCString &n, bool &ambig)
Definition util.cpp:3417
int getScopeFragment(const QCString &s, int p, int *l)
Definition util.cpp:5139
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:5413
A bunch of utility functions.
void generateXML()
Definition xmlgen.cpp:2204