Doxygen
Loading...
Searching...
No Matches
filedef.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 *
4 *
5 * Copyright (C) 1997-2015 by Dimitri van Heesch.
6 *
7 * Permission to use, copy, modify, and distribute this software and its
8 * documentation under the terms of the GNU General Public License is hereby
9 * granted. No representations are made about the suitability of this software
10 * for any purpose. It is provided "as is" without express or implied warranty.
11 * See the GNU General Public License for more details.
12 *
13 * Documents produced by Doxygen are derivative works derived from the
14 * input used in their production; they are not affected by this license.
15 *
16 */
17
18#include <unordered_set>
19
20#include "memberlist.h"
21#include "classlist.h"
22#include "filedef.h"
23#include "doxygen.h"
24#include "memberdef.h"
25#include "classdef.h"
26#include "namespacedef.h"
27#include "util.h"
28#include "language.h"
29#include "outputlist.h"
30#include "dot.h"
31#include "dotincldepgraph.h"
32#include "message.h"
33#include "docparser.h"
34#include "searchindex.h"
35#include "htags.h"
36#include "parserintf.h"
37#include "portable.h"
38#include "vhdldocgen.h"
39#include "debug.h"
40#include "layout.h"
41#include "entry.h"
42#include "groupdef.h"
43#include "filename.h"
44#include "membergroup.h"
45#include "dirdef.h"
46#include "config.h"
47#include "clangparser.h"
48#include "settings.h"
49#include "definitionimpl.h"
50#include "conceptdef.h"
51#include "outputlist.h"
52#include "moduledef.h"
53
54//---------------------------------------------------------------------------
55
57{
58 bool isIDLorJava = lang==SrcLangExt::IDL || lang==SrcLangExt::Java;
59 if (isIDLorJava || (kind & IncludeKind_ImportMask))
60 {
61 return "import ";
62 }
63 else if (kind & IncludeKind_ObjCMask)
64 {
65 return "#import ";
66 }
67 else
68 {
69 return "#include ";
70 }
71}
72
74{
75 if (lang==SrcLangExt::Java || kind==IncludeKind::ImportModule) return "";
76 if ((kind & IncludeKind_LocalMask) || (lang==SrcLangExt::IDL))
77 {
78 return "\"";
79 }
80 else
81 {
82 return "<";
83 }
84}
85
87{
88 if (lang==SrcLangExt::IDL) return "\";";
89 else if (lang==SrcLangExt::Java) return ";";
90
91 switch (kind)
92 {
93 case IncludeKind::ImportLocal: return "\";";
94 case IncludeKind::ImportLocalObjC: return "\"";
95 case IncludeKind::IncludeLocal: return "\"";
96 case IncludeKind::ImportSystem: return ">;";
97 case IncludeKind::ImportSystemObjC: return ">";
98 case IncludeKind::IncludeSystem: return ">";
99 case IncludeKind::ImportModule: return ";";
100 }
101 return "";
102}
103
105{
106 QCString result;
107 bool isIDLorJava = lang==SrcLangExt::IDL || lang==SrcLangExt::Java;
108 result.sprintf("local=\"%s\" import=\"%s\" module=\"%s\" objc=\"%s\"",
109 (kind & IncludeKind_LocalMask) ? "yes" : "no",
110 (isIDLorJava || (kind & IncludeKind_ImportMask)) ? "yes" : "no",
111 (kind==IncludeKind::ImportModule) ? "yes" : "no",
112 (kind & IncludeKind_ObjCMask) ? "yes" : "no");
113 return result;
114}
115
116//---------------------------------------------------------------------------
117
118using DefinitionLineMap = std::unordered_map<int,const Definition *>;
119using MemberDefLineMap = std::unordered_map<int,const MemberDef *>;
120using IncludeInfoMap = std::unordered_map<std::string, const IncludeInfo *>;
121
122class FileDefImpl : public DefinitionMixin<FileDef>
123{
124 public:
125 FileDefImpl(const QCString &p,const QCString &n,const QCString &ref=QCString(),const QCString &dn=QCString());
126 ~FileDefImpl() override;
128
129 DefType definitionType() const override { return TypeFile; }
131 const QCString &name() const override;
132
133 QCString displayName(bool=TRUE) const override { return localName(); }
134 QCString fileName() const override { return m_fileName; }
135 QCString getOutputFileBase() const override;
136 QCString anchor() const override { return QCString(); }
137 QCString getSourceFileBase() const override;
138 QCString includeName() const override;
141 QCString absFilePath() const override { return m_filePath; }
142 const QCString &docName() const override { return m_docname; }
143 bool isSource() const override { return m_isSource; }
144 bool isDocumentationFile() const override;
145 const Definition *getSourceDefinition(int lineNr) const override;
146 const MemberDef *getSourceMember(int lineNr) const override;
147 QCString getPath() const override { return m_path; }
148 QCString getVersion() const override { return m_fileVersion; }
149 bool isLinkableInProject() const override;
150 bool isLinkable() const override { return isLinkableInProject() || isReference(); }
151 bool isIncluded(const QCString &name) const override;
152 DirDef *getDirDef() const override { return m_dir; }
153 ModuleDef *getModuleDef() const override { return m_moduleDef; }
154 const LinkedRefMap<NamespaceDef> &getUsedNamespaces() const override;
156 const IncludeInfoList &includeFileList() const override { return m_includeList; }
157 const IncludeInfoList &includedByFileList() const override { return m_includedByList; }
158 void getAllIncludeFilesRecursively(StringVector &incFiles) const override;
159 MemberList *getMemberList(MemberListType lt) const override;
160 const MemberLists &getMemberLists() const override { return m_memberLists; }
161 const MemberGroupList &getMemberGroups() const override { return m_memberGroups; }
162 const NamespaceLinkedRefMap &getNamespaces() const override { return m_namespaces; }
163 const ConceptLinkedRefMap &getConcepts() const override { return m_concepts; }
164 const ClassLinkedRefMap &getClasses() const override { return m_classes; }
165 QCString title() const override;
166 bool hasDetailedDescription() const override;
167 QCString fileVersion() const override;
168 bool subGrouping() const override { return m_subGrouping; }
169 void countMembers() override;
170 int numDocMembers() const override;
171 int numDecMembers() const override;
172 void addSourceRef(int line,const Definition *d,const MemberDef *md) override;
173 void writeDocumentation(OutputList &ol) override;
174 void writeMemberPages(OutputList &ol) override;
175 void writeQuickMemberLinks(OutputList &ol,const MemberDef *currentMd) const override;
176 void writeSummaryLinks(OutputList &ol) const override;
177 void writePageNavigation(OutputList &ol) const override;
178 void writeTagFile(TextStream &t) override;
179 void writeSourceHeader(OutputList &ol) override;
180 void writeSourceBody(OutputList &ol,ClangTUParser *clangParser) override;
181 void writeSourceFooter(OutputList &ol) override;
182 void parseSource(ClangTUParser *clangParser) override;
183 void setDiskName(const QCString &name) override;
184 void insertMember(MemberDef *md) override;
185 void removeMember(MemberDef *md) override;
186 void insertClass(ClassDef *cd) override;
187 void insertConcept(ConceptDef *cd) override;
188 void insertNamespace(NamespaceDef *nd) override;
189 void computeAnchors() override;
190 void setDirDef(DirDef *dd) override { m_dir=dd; }
191 void setModuleDef(ModuleDef *mod) override { m_moduleDef=mod; }
192 void addUsingDirective(NamespaceDef *nd) override;
193 void addUsingDeclaration(const Definition *d) override;
194 void combineUsingRelations() override;
195 bool generateSourceFile() const override;
196 void sortMemberLists() override;
197 void addIncludeDependency(const FileDef *fd,const QCString &incName,IncludeKind kind) override;
198 void addIncludedByDependency(const FileDef *fd,const QCString &incName,IncludeKind kind) override;
199 void addMembersToMemberGroup() override;
201 void findSectionsInDocumentation() override;
202 void addIncludedUsingDirectives(FileDefSet &visitedFiles) override;
203 void addListReferences() override;
204
205 bool hasIncludeGraph() const override;
206 bool hasIncludedByGraph() const override;
207 void overrideIncludeGraph(bool e) override;
208 void overrideIncludedByGraph(bool e) override;
209
210 private:
211 void setDiskNameLocal(const QCString &name);
212 void acquireFileVersion();
221 void writeSourceLink(OutputList &ol);
223 bool isConstantGroup);
225 void writeConcepts(OutputList &ol,const QCString &title);
235
253 DirDef *m_dir = nullptr;
264 bool m_hasIncludeGraph = Config_getBool(INCLUDE_GRAPH);
265 bool m_hasIncludedByGraph = Config_getBool(INCLUDED_BY_GRAPH);
266};
267
268std::unique_ptr<FileDef> createFileDef(const QCString &p,const QCString &n,const QCString &ref,const QCString &dn)
269{
270 return std::make_unique<FileDefImpl>(p,n,ref,dn);
271}
272
273
274//---------------------------------------------------------------------------
275
276/*! create a new file definition, where \a p is the file path,
277 \a nm the file name, and \a lref is an HTML anchor name if the
278 file was read from a tag file or nullptr otherwise
279*/
281 const QCString &lref,const QCString &dn)
282 : DefinitionMixin(p+nm,1,1,nm,nullptr,nullptr,!p.isEmpty())
283{
285 m_filePath=p+nm;
286 m_fileName=nm;
287
288 setReference(lref);
289 setDiskNameLocal(!dn.isEmpty() ? dn : nm);
290 m_isSource = guessSection(nm).isSource();
291 m_docname = nm;
292 m_dir = nullptr;
293 if (Config_getBool(FULL_PATH_NAMES))
294 {
296 }
298 Config_getBool(FULL_PATH_NAMES) ? m_fileName : DefinitionMixin::name()));
300 m_subGrouping=Config_getBool(SUBGROUPING);
301}
302
303/*! destroy the file definition */
307
309{
310 if (isReference())
311 {
313 m_inclDepFileName = name+"_incl";
314 m_inclByDepFileName = name+"_dep_incl";
315 }
316 else
317 {
321 }
322}
323
328
329/*! Compute the HTML anchor names for all members in the class */
331{
332 MemberList *ml = getMemberList(MemberListType::AllMembersList());
333 if (ml) ml->setAnchors();
334}
335
337{
338 //printf("FileDefImpl::distributeMemberGroupDocumentation()\n");
339 for (const auto &mg : m_memberGroups)
340 {
341 mg->distributeMemberGroupDocumentation();
342 }
343}
344
346{
350 for (const auto &mg : m_memberGroups)
351 {
352 mg->findSectionsInDocumentation(this);
353 }
354
355 for (auto &ml : m_memberLists)
356 {
357 if (ml->listType().isDeclaration())
358 {
359 ml->findSectionsInDocumentation(this);
360 }
361 }
362}
363
365{
366 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
367 bool sourceBrowser = Config_getBool(SOURCE_BROWSER);
368 return ((!briefDescription().isEmpty() && repeatBrief) ||
369 !documentation().stripWhiteSpace().isEmpty() || // avail empty section
370 (sourceBrowser && getStartBodyLine()!=-1 && getBodyDef())
371 );
372}
373
375{
378 tagFile << " <compound kind=\"file\">\n";
379 tagFile << " <name>" << convertToXML(name()) << "</name>\n";
380 tagFile << " <path>" << convertToXML(stripFromPath(getPath())) << "</path>\n";
381 tagFile << " <filename>" << fn << "</filename>\n";
382 for (const auto &ii : m_includeList)
383 {
384 const FileDef *fd=ii.fileDef;
385 if (fd && fd->isLinkable() && !fd->isReference())
386 {
387 QCString attr = includeTagFileAttributes(fd->getLanguage(),ii.kind);
388 tagFile << " <includes id=\""
389 << convertToXML(fd->getOutputFileBase()) << "\" "
390 << "name=\"" << convertToXML(fd->name()) << "\" "
391 << attr << ">"
392 << convertToXML(ii.includeName)
393 << "</includes>\n";
394 }
395 }
396 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::File))
397 {
398 switch (lde->kind())
399 {
400 case LayoutDocEntry::FileClasses:
401 {
403 }
404 break;
405 case LayoutDocEntry::FileInterfaces:
406 {
408 }
409 break;
410 case LayoutDocEntry::FileStructs:
411 {
413 }
414 break;
415 case LayoutDocEntry::FileExceptions:
416 {
418 }
419 break;
420 case LayoutDocEntry::FileConcepts:
421 {
422 for (const auto *nd : m_concepts)
423 {
424 if (nd->isLinkableInProject())
425 {
426 tagFile << " <concept>" << convertToXML(nd->name()) << "</concept>\n";
427 }
428 }
429 }
430 break;
431 case LayoutDocEntry::FileNamespaces:
432 {
433 for (const auto *nd : m_namespaces)
434 {
435 if (nd->isLinkableInProject())
436 {
437 tagFile << " <namespace>" << convertToXML(nd->name()) << "</namespace>\n";
438 }
439 }
440 }
441 break;
442 case LayoutDocEntry::MemberDecl:
443 {
444 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
445 if (lmd)
446 {
447 MemberList * ml = getMemberList(lmd->type);
448 if (ml)
449 {
450 ml->writeTagFile(tagFile,false,false);
451 }
452 }
453 }
454 break;
455 case LayoutDocEntry::MemberGroups:
456 {
457 for (const auto &mg : m_memberGroups)
458 {
459 mg->writeTagFile(tagFile);
460 }
461 }
462 break;
463 default:
464 break;
465 }
466 }
467
469 tagFile << " </compound>\n";
470}
471
473{
475 {
478 ol.writeRuler();
482 ol.writeAnchor(QCString(),"details");
484 ol.startGroupHeader("details");
485 ol.parseText(title);
486 ol.endGroupHeader();
487
488 ol.startTextBlock();
489 if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF))
490 {
492 briefLine(),
493 this,
494 nullptr,
496 DocOptions());
497 }
498 if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF) &&
499 !documentation().isEmpty())
500 {
504 ol.enableAll();
507 ol.writeString("\n\n");
509 }
510 if (!documentation().isEmpty())
511 {
512 ol.generateDoc(docFile(),
513 docLine(),
514 this,
515 nullptr,
516 documentation()+"\n",
517 DocOptions()
518 .setIndexWords(true));
519 }
520 //printf("Writing source ref for file %s\n",qPrint(name()));
521 if (Config_getBool(SOURCE_BROWSER))
522 {
523 ol.startParagraph("definition");
524 QCString refText = theTranslator->trDefinedInSourceFile();
525 int fileMarkerPos = refText.find("@0");
526 if (fileMarkerPos!=-1) // should always pass this.
527 {
528 ol.parseText(refText.left(fileMarkerPos)); //text left from marker 1
530 ol.parseText(refText.right(
531 refText.length()-fileMarkerPos-2)); // text right from marker 2
532 }
533 else
534 {
535 err("translation error: invalid marker in trDefinedInSourceFile()\n");
536 }
537 ol.endParagraph();
538 }
539 ol.endTextBlock();
540 }
541}
542
544{
546 {
547 auto parser { createDocParser() };
548 auto ast { validatingParseDoc(*parser.get(),
549 briefFile(),
550 briefLine(),
551 this,
552 nullptr,
554 DocOptions()
555 .setIndexWords(true)
556 .setSingleLine(true))
557 };
558 if (!ast->isEmpty())
559 {
560 ol.startParagraph();
563 ol.writeString(" - ");
565 ol.writeDoc(ast.get(),this,nullptr);
568 ol.writeString(" \n");
570
571 if (Config_getBool(REPEAT_BRIEF) ||
572 !documentation().stripWhiteSpace().isEmpty()
573 )
574 {
576 ol.startTextLink(QCString(),"details");
577 ol.parseText(theTranslator->trMore());
578 ol.endTextLink();
579 }
581 ol.endParagraph();
582 }
583 }
584 ol.writeSynopsis();
585}
586
588{
589 for (const auto &cd : list)
590 {
591 if (cd->isLinkableInProject())
592 {
593 tagFile << " <class kind=\"" << cd->compoundTypeString() <<
594 "\">" << convertToXML(cd->name()) << "</class>\n";
595 }
596 }
597}
598
600{
601 if (!m_includeList.empty())
602 {
604 for (const auto &ii : m_includeList)
605 {
606 const FileDef *fd=ii.fileDef;
607 ol.startTypewriter();
608 SrcLangExt lang = fd ? fd->getLanguage() : SrcLangExt::Cpp;
609 ol.docify(::includeStatement(lang,ii.kind));
610 ol.docify(::includeOpen(lang,ii.kind));
612 ol.docify(ii.includeName);
613 ol.enableAll();
615
616 // Here we use the include file name as it appears in the file.
617 // we could also we the name as it is used within doxygen,
618 // then we should have used fd->docName() instead of ii->includeName
619 if (fd && fd->isLinkable())
620 {
623 QCString(),ii.includeName);
624 }
625 else
626 {
628 if (ii.kind==IncludeKind::ImportModule && mod && mod->isLinkable())
629 {
631 QCString(),ii.includeName);
632 }
633 else
634 {
635 ol.docify(ii.includeName);
636 }
637 }
638
639 ol.enableAll();
640 ol.docify(::includeClose(lang,ii.kind));
641 ol.endTypewriter();
642 ol.lineBreak();
643 }
644 ol.endTextBlock();
645 }
646}
647
649{
650 if (Config_getBool(HAVE_DOT) && m_hasIncludeGraph /*&& Config_getBool(INCLUDE_GRAPH)*/)
651 {
652 //printf("Graph for file %s\n",qPrint(name()));
653 DotInclDepGraph incDepGraph(this,FALSE);
654 if (incDepGraph.isTooBig())
655 {
656 warn_uncond("Include graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
657 qPrint(name()), incDepGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
658 }
659 else if (!incDepGraph.isTrivial())
660 {
661 ol.startTextBlock();
664 ol.parseText(theTranslator->trInclDepGraph(name()));
665 ol.endInclDepGraph(incDepGraph);
666 ol.enableAll();
667 ol.endTextBlock(TRUE);
668 }
669 //incDepGraph.writeGraph(Config_getString(HTML_OUTPUT),fd->getOutputFileBase());
670 }
671}
672
674{
675 if (Config_getBool(HAVE_DOT) && m_hasIncludedByGraph /*&& Config_getBool(INCLUDED_BY_GRAPH)*/)
676 {
677 //printf("Graph for file %s\n",qPrint(name()));
678 DotInclDepGraph incDepGraph(this,TRUE);
679 if (incDepGraph.isTooBig())
680 {
681 warn_uncond("Included by graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
682 qPrint(name()), incDepGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
683 }
684 else if (!incDepGraph.isTrivial())
685 {
686 ol.startTextBlock();
689 ol.parseText(theTranslator->trInclByDepGraph());
690 ol.endInclDepGraph(incDepGraph);
691 ol.enableAll();
692 ol.endTextBlock(TRUE);
693 }
694 //incDepGraph.writeGraph(Config_getString(HTML_OUTPUT),fd->getOutputFileBase());
695 }
696}
697
698
700{
701 //printf("%s: generateSourceFile()=%d\n",qPrint(name()),generateSourceFile());
702 if (generateSourceFile())
703 {
705 ol.startParagraph();
707 ol.parseText(theTranslator->trGotoSourceCode());
708 ol.endTextLink();
709 ol.endParagraph();
710 ol.enableAll();
711 }
712}
713
715 bool const isConstantGroup)
716{
717 // write list of namespaces
718 m_namespaces.writeDeclaration(ol,title,isConstantGroup);
719}
720
722{
723 // write list of classes
724 list.writeDeclaration(ol,nullptr,title,FALSE);
725}
726
728{
729 // write list of classes
730 m_concepts.writeDeclaration(ol,title,FALSE);
731}
732
734{
735 // temporarily undo the disabling could be done by startMemberDocumentation()
736 // as a result of setting SEPARATE_MEMBER_PAGES to YES; see bug730512
737 bool isEnabled = ol.isEnabled(OutputType::Html);
739
740 m_classes.writeDocumentation(ol,this);
741
742 // restore the initial state if needed
743 if (!isEnabled) ol.disable(OutputType::Html);
744}
745
750
755
757{
758 if (Config_getBool(SEPARATE_MEMBER_PAGES))
759 {
762 }
763}
764
766{
767 if (Config_getBool(SEPARATE_MEMBER_PAGES))
768 {
771 }
772}
773
775{
776 /* write user defined member groups */
777 for (const auto &mg : m_memberGroups)
778 {
779 if (!mg->allMembersInSameSection() || !m_subGrouping)
780 {
781 mg->writeDeclarations(ol,nullptr,nullptr,this,nullptr,nullptr);
782 }
783 }
784}
785
787{
788 // write Author section (Man only)
791 ol.startGroupHeader();
792 ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
793 ol.endGroupHeader();
794 ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString(PROJECT_NAME)));
796}
797
799{
802 bool first=TRUE;
803 SrcLangExt lang=getLanguage();
804 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::File))
805 {
806 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
807 if (lde->kind()==LayoutDocEntry::FileClasses && m_classes.declVisible() && ls)
808 {
809 QCString label = "nested-classes";
810 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
811 first=FALSE;
812 }
813 else if (lde->kind()==LayoutDocEntry::FileInterfaces && m_interfaces.declVisible() && ls)
814 {
815 QCString label = "interfaces";
816 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
817 first=FALSE;
818 }
819 else if (lde->kind()==LayoutDocEntry::FileStructs && m_structs.declVisible() && ls)
820 {
821 QCString label = "structs";
822 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
823 first=FALSE;
824 }
825 else if (lde->kind()==LayoutDocEntry::FileExceptions && m_exceptions.declVisible() && ls)
826 {
827 QCString label = "exceptions";
828 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
829 first=FALSE;
830 }
831 else if (lde->kind()==LayoutDocEntry::FileNamespaces && m_namespaces.declVisible(false) && ls)
832 {
833 QCString label = "namespaces";
834 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
835 first=FALSE;
836 }
837 else if (lde->kind()==LayoutDocEntry::FileConcepts && m_concepts.declVisible() && ls)
838 {
839 QCString label = "concepts";
840 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
841 first=FALSE;
842 }
843 else if (lde->kind()==LayoutDocEntry::MemberDecl)
844 {
845 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
846 if (lmd)
847 {
848 MemberList * ml = getMemberList(lmd->type);
849 if (ml && ml->declVisible())
850 {
851 ol.writeSummaryLink(QCString(),ml->listType().toLabel(),lmd->title(lang),first);
852 first=FALSE;
853 }
854 }
855 }
856 }
857 if (!first)
858 {
859 ol.writeString(" </div>\n");
860 }
862}
863
868
869/*! Write the documentation page for this file to the file of output
870 generators \a ol.
871*/
873{
874 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
875 //funcList->countDecMembers();
876
877 //QCString fn = name();
878 //if (Config_getBool(FULL_PATH_NAMES))
879 //{
880 // fn.prepend(stripFromPath(getPath()));
881 //}
882
883 //printf("WriteDocumentation diskname=%s\n",qPrint(diskname));
884
885 QCString versionTitle;
886 if (!m_fileVersion.isEmpty())
887 {
888 versionTitle=("("+m_fileVersion+")");
889 }
890 QCString title = m_docname+versionTitle;
891 QCString pageTitle;
892 if (Config_getBool(HIDE_COMPOUND_REFERENCE))
893 {
894 pageTitle=m_docname;
895 }
896 else
897 {
898 pageTitle=theTranslator->trFileReference(m_docname);
899 }
900
901 if (getDirDef())
902 {
903 startFile(ol,getOutputFileBase(),false,name(),pageTitle,HighlightedItem::FileVisible,!generateTreeView);
904 if (!generateTreeView)
905 {
907 ol.endQuickIndices();
908 }
909 startTitle(ol,getOutputFileBase(),this);
912 if (Config_getBool(HIDE_COMPOUND_REFERENCE))
913 {
914 ol.parseText(displayName()); // Html only
915 }
916 else
917 {
918 ol.parseText(theTranslator->trFileReference(displayName())); // Html only
919 }
920 ol.enableAll();
922 if (Config_getBool(HIDE_COMPOUND_REFERENCE))
923 {
924 ol.parseText(Config_getBool(FULL_PATH_NAMES) ? // other output formats
925 pageTitle :
926 name());
927 }
928 else
929 {
930 ol.parseText(Config_getBool(FULL_PATH_NAMES) ? // other output formats
931 pageTitle :
932 theTranslator->trFileReference(name()));
933 }
935 addGroupListToTitle(ol,this);
937 }
938 else
939 {
940 startFile(ol,getOutputFileBase(),false,name(),pageTitle,HighlightedItem::FileVisible,!generateTreeView);
941 if (!generateTreeView)
942 {
943 ol.endQuickIndices();
944 }
945 startTitle(ol,getOutputFileBase(),this);
946 ol.parseText(pageTitle);
947 addGroupListToTitle(ol,this);
949 }
950
951 ol.startContents();
952
953 if (!m_fileVersion.isEmpty())
954 {
957 ol.docify(versionTitle);
958 ol.endProjectNumber();
959 ol.enableAll();
960 }
961
962 //---------------------------------------- start flexible part -------------------------------
963
964 SrcLangExt lang = getLanguage();
965 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::File))
966 {
967 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
968 switch (lde->kind())
969 {
970 case LayoutDocEntry::BriefDesc:
972 break;
973 case LayoutDocEntry::MemberDeclStart:
975 break;
976 case LayoutDocEntry::FileIncludes:
978 break;
979 case LayoutDocEntry::FileIncludeGraph:
981 break;
982 case LayoutDocEntry::FileIncludedByGraph:
984 break;
985 case LayoutDocEntry::FileSourceLink:
986 writeSourceLink(ol);
987 break;
988 case LayoutDocEntry::FileClasses:
989 if (ls) writeClassDeclarations(ol,ls->title(lang),m_classes);
990 break;
991 case LayoutDocEntry::FileInterfaces:
992 if (ls) writeClassDeclarations(ol,ls->title(lang),m_interfaces);
993 break;
994 case LayoutDocEntry::FileStructs:
995 if (ls) writeClassDeclarations(ol,ls->title(lang),m_structs);
996 break;
997 case LayoutDocEntry::FileExceptions:
998 if (ls) writeClassDeclarations(ol,ls->title(lang),m_exceptions);
999 break;
1000 case LayoutDocEntry::FileConcepts:
1001 if (ls) writeConcepts(ol,ls->title(lang));
1002 break;
1003 case LayoutDocEntry::FileNamespaces:
1004 if (ls) writeNamespaceDeclarations(ol,ls->title(lang),false);
1005 break;
1006 case LayoutDocEntry::FileConstantGroups:
1007 if (ls) writeNamespaceDeclarations(ol,ls->title(lang),true);
1008 break;
1009 case LayoutDocEntry::MemberGroups:
1011 break;
1012 case LayoutDocEntry::MemberDecl:
1013 {
1014 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
1015 if (lmd) writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
1016 }
1017 break;
1018 case LayoutDocEntry::MemberDeclEnd:
1020 break;
1021 case LayoutDocEntry::DetailedDesc:
1022 if (ls) writeDetailedDescription(ol,ls->title(lang));
1023 break;
1024 case LayoutDocEntry::MemberDefStart:
1026 break;
1027 case LayoutDocEntry::FileInlineClasses:
1029 break;
1030 case LayoutDocEntry::MemberDef:
1031 {
1032 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
1033 if (lmd) writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
1034 }
1035 break;
1036 case LayoutDocEntry::MemberDefEnd:
1038 break;
1039 case LayoutDocEntry::AuthorSection:
1041 break;
1042 case LayoutDocEntry::ClassIncludes:
1043 case LayoutDocEntry::ClassInheritanceGraph:
1044 case LayoutDocEntry::ClassNestedClasses:
1045 case LayoutDocEntry::ClassCollaborationGraph:
1046 case LayoutDocEntry::ClassAllMembersLink:
1047 case LayoutDocEntry::ClassUsedFiles:
1048 case LayoutDocEntry::ClassInlineClasses:
1049 case LayoutDocEntry::NamespaceNestedNamespaces:
1050 case LayoutDocEntry::NamespaceNestedConstantGroups:
1051 case LayoutDocEntry::NamespaceClasses:
1052 case LayoutDocEntry::NamespaceConcepts:
1053 case LayoutDocEntry::NamespaceInterfaces:
1054 case LayoutDocEntry::NamespaceStructs:
1055 case LayoutDocEntry::NamespaceExceptions:
1056 case LayoutDocEntry::NamespaceInlineClasses:
1057 case LayoutDocEntry::ConceptDefinition:
1058 case LayoutDocEntry::GroupClasses:
1059 case LayoutDocEntry::GroupConcepts:
1060 case LayoutDocEntry::GroupModules:
1061 case LayoutDocEntry::GroupInlineClasses:
1062 case LayoutDocEntry::GroupNamespaces:
1063 case LayoutDocEntry::GroupDirs:
1064 case LayoutDocEntry::GroupNestedGroups:
1065 case LayoutDocEntry::GroupFiles:
1066 case LayoutDocEntry::GroupGraph:
1067 case LayoutDocEntry::GroupPageDocs:
1068 case LayoutDocEntry::ModuleExports:
1069 case LayoutDocEntry::ModuleClasses:
1070 case LayoutDocEntry::ModuleConcepts:
1071 case LayoutDocEntry::ModuleUsedFiles:
1072 case LayoutDocEntry::DirSubDirs:
1073 case LayoutDocEntry::DirFiles:
1074 case LayoutDocEntry::DirGraph:
1075 err("Internal inconsistency: member '{}' should not be part of "
1076 "LayoutDocManager::File entry list\n",lde->entryToString());
1077 break;
1078 }
1079 }
1080
1081 //---------------------------------------- end flexible part -------------------------------
1082
1083 ol.endContents();
1084
1085 endFileWithNavPath(ol,this);
1086
1087 if (Config_getBool(SEPARATE_MEMBER_PAGES))
1088 {
1089 MemberList *ml = getMemberList(MemberListType::AllMembersList());
1090 if (ml) ml->sort();
1091 writeMemberPages(ol);
1092 }
1093}
1094
1096{
1097 ol.pushGeneratorState();
1099
1100 for (const auto &ml : m_memberLists)
1101 {
1102 if (ml->listType().isDocumentation())
1103 {
1104 ml->writeDocumentationPage(ol,name(),this);
1105 }
1106 }
1107
1108 ol.popGeneratorState();
1109}
1110
1112{
1113 bool createSubDirs=Config_getBool(CREATE_SUBDIRS);
1114
1115 ol.writeString(" <div class=\"navtab\">\n");
1116 ol.writeString(" <table>\n");
1117
1118 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
1119 if (allMemberList)
1120 {
1121 for (const auto &md : *allMemberList)
1122 {
1123 if (md->getFileDef()==this && md->getNamespaceDef()==nullptr && md->isLinkable() && !md->isEnumValue())
1124 {
1125 if (md->isLinkableInProject())
1126 {
1127 QCString fn=md->getOutputFileBase();
1129 if (md==currentMd) // selected item => highlight
1130 {
1131 ol.writeString(" <tr><td class=\"navtabHL\">");
1132 }
1133 else
1134 {
1135 ol.writeString(" <tr><td class=\"navtab\">");
1136 }
1137 ol.writeString("<span class=\"label\"><a ");
1138 ol.writeString("href=\"");
1139 if (createSubDirs) ol.writeString("../../");
1140 ol.writeString(fn+"#"+md->anchor());
1141 ol.writeString("\">");
1142 ol.writeString(convertToHtml(md->localName()));
1143 ol.writeString("</a></span>");
1144 ol.writeString("</td></tr>\n");
1145 }
1146 }
1147 }
1148 }
1149
1150 ol.writeString(" </table>\n");
1151 ol.writeString(" </div>\n");
1152}
1153
1154/*! Write a source listing of this file to the output */
1156{
1157 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
1159 if (!m_fileVersion.isEmpty())
1160 {
1161 title+=(" ("+m_fileVersion+")");
1162 }
1163 QCString pageTitle = theTranslator->trSourceFile(title);
1165
1166 bool isDocFile = isDocumentationFile();
1167 bool genSourceFile = !isDocFile && generateSourceFile();
1168 if (getDirDef())
1169 {
1171 !generateTreeView,
1172 !isDocFile && genSourceFile ? QCString() : getOutputFileBase(),
1173 0);
1174 if (!generateTreeView)
1175 {
1177 ol.endQuickIndices();
1178 }
1180 ol.parseText(name());
1182 }
1183 else
1184 {
1186 !isDocFile && genSourceFile ? QCString() : getOutputFileBase(),
1187 0);
1189 ol.parseText(title);
1191 }
1192
1193 ol.startContents();
1194
1195 if (isLinkable())
1196 {
1198 ol.parseText(theTranslator->trGotoDocumentation());
1199 ol.endTextLink();
1200
1201 ol.pushGeneratorState();
1203 ol.writeString("\\par\n");
1204 ol.popGeneratorState();
1205 }
1206}
1207
1208void FileDefImpl::writeSourceBody(OutputList &ol,[[maybe_unused]] ClangTUParser *clangParser)
1209{
1210 bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);
1211 OutputCodeList devNullList;
1212 devNullList.add<DevNullCodeGenerator>();
1213#if USE_LIBCLANG
1214 if (Doxygen::clangAssistedParsing && clangParser &&
1215 (getLanguage()==SrcLangExt::Cpp || getLanguage()==SrcLangExt::ObjC))
1216 {
1217 auto &codeOL = ol.codeGenerators();
1218 codeOL.startCodeFragment("DoxyCode");
1219 clangParser->switchToFile(this);
1220 clangParser->writeSources(codeOL,this);
1221 codeOL.endCodeFragment("DoxyCode");
1222 }
1223 else
1224#endif
1225 {
1226 auto intf = Doxygen::parserManager->getCodeParser(getDefFileExtension());
1227 intf->resetCodeParserState();
1228 auto &codeOL = ol.codeGenerators();
1229 codeOL.startCodeFragment("DoxyCode");
1230 bool needs2PassParsing =
1231 Doxygen::parseSourcesNeeded && // we need to parse (filtered) sources for cross-references
1232 !filterSourceFiles && // but user wants to show sources as-is
1233 !getFileFilter(absFilePath(),TRUE).isEmpty(); // and there is a filter used while parsing
1234
1235 if (needs2PassParsing)
1236 {
1237 // parse code for cross-references only (see bug707641)
1238 intf->parseCode(devNullList,QCString(),
1240 getLanguage(),
1241 Config_getBool(STRIP_CODE_COMMENTS),
1242 FALSE,QCString(),this
1243 );
1244 }
1245 size_t indent = 0;
1246 intf->parseCode(codeOL,QCString(),
1247 detab(fileToString(absFilePath(),filterSourceFiles,TRUE),indent),
1248 getLanguage(), // lang
1249 Config_getBool(STRIP_CODE_COMMENTS),
1250 FALSE, // isExampleBlock
1251 QCString(), // exampleName
1252 this, // fileDef
1253 -1, // startLine
1254 -1, // endLine
1255 FALSE, // inlineFragment
1256 nullptr, // memberDef
1257 TRUE, // showLineNumbers
1258 nullptr, // searchCtx
1259 !needs2PassParsing // collectXRefs
1260 );
1261 codeOL.endCodeFragment("DoxyCode");
1262 }
1263}
1264
1266{
1267 ol.endContents();
1268 endFileWithNavPath(ol,this,false);
1269 ol.enableAll();
1270}
1271
1272void FileDefImpl::parseSource([[maybe_unused]] ClangTUParser *clangParser)
1273{
1274 bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);
1275 OutputCodeList devNullList;
1276 devNullList.add<DevNullCodeGenerator>();
1277#if USE_LIBCLANG
1278 if (Doxygen::clangAssistedParsing && clangParser &&
1279 (getLanguage()==SrcLangExt::Cpp || getLanguage()==SrcLangExt::ObjC))
1280 {
1281 clangParser->switchToFile(this);
1282 clangParser->writeSources(devNullList,this);
1283 }
1284 else
1285#endif
1286 {
1287 auto intf = Doxygen::parserManager->getCodeParser(getDefFileExtension());
1288 intf->resetCodeParserState();
1289 size_t indent = 0;
1290 intf->parseCode(
1291 devNullList,QCString(),
1292 detab(fileToString(absFilePath(),filterSourceFiles,TRUE),indent),
1293 getLanguage(),
1294 Config_getBool(STRIP_CODE_COMMENTS),
1295 FALSE,QCString(),this
1296 );
1297 }
1298}
1299
1301{
1302 for (auto &ml : m_memberLists)
1303 {
1304 if (ml->listType().isDeclaration())
1305 {
1307 }
1308 }
1309
1310 // add members inside sections to their groups
1311 for (const auto &mg : m_memberGroups)
1312 {
1313 if (mg->allMembersInSameSection() && m_subGrouping)
1314 {
1315 //printf("----> addToDeclarationSection(%s)\n",qPrint(mg->header()));
1316 mg->addToDeclarationSection();
1317 }
1318 }
1319}
1320
1321/*! Adds member definition \a md to the list of all members of this file */
1323{
1324 if (md->isHidden()) return;
1325 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
1326 //printf("%s:FileDefImpl::insertMember(%s (=%p) list has %zu elements)\n",
1327 // qPrint(name()),qPrint(md->name()),(void*)md,allMemberList ? allMemberList->size() : 0);
1328 if (allMemberList && allMemberList->contains(md))
1329 {
1330 //printf("already added\n");
1331 return;
1332 }
1333
1334 if (allMemberList==nullptr)
1335 {
1336 m_memberLists.emplace_back(std::make_unique<MemberList>(MemberListType::AllMembersList(),MemberListContainer::File));
1337 allMemberList = m_memberLists.back().get();
1338 }
1339 allMemberList->push_back(md);
1340 switch (md->memberType())
1341 {
1343 if (md->getLanguage() == SrcLangExt::Python)
1344 {
1345 addMemberToList(MemberListType::PropertyMembers(),md);
1346 addMemberToList(MemberListType::Properties(),md);
1347 break;
1348 }
1349 // fallthrough, explicitly no break here
1351 addMemberToList(MemberListType::DecVarMembers(),md);
1352 addMemberToList(MemberListType::DocVarMembers(),md);
1353 break;
1355 addMemberToList(MemberListType::DecFuncMembers(),md);
1356 addMemberToList(MemberListType::DocFuncMembers(),md);
1357 break;
1359 addMemberToList(MemberListType::DecTypedefMembers(),md);
1360 addMemberToList(MemberListType::DocTypedefMembers(),md);
1361 break;
1363 addMemberToList(MemberListType::DecSequenceMembers(),md);
1364 addMemberToList(MemberListType::DocSequenceMembers(),md);
1365 break;
1367 addMemberToList(MemberListType::DecDictionaryMembers(),md);
1368 addMemberToList(MemberListType::DocDictionaryMembers(),md);
1369 break;
1371 addMemberToList(MemberListType::DecEnumMembers(),md);
1372 addMemberToList(MemberListType::DocEnumMembers(),md);
1373 break;
1374 case MemberType::EnumValue: // enum values are shown inside their enums
1375 break;
1376 case MemberType::Define:
1377 addMemberToList(MemberListType::DecDefineMembers(),md);
1378 addMemberToList(MemberListType::DocDefineMembers(),md);
1379 break;
1380 default:
1381 err("FileDefImpl::insertMembers(): "
1382 "member '{}' with class scope '{}' inserted in file scope '{}'!\n",
1383 md->name(),
1384 md->getClassDef() ? md->getClassDef()->name() : "<global>",
1385 name());
1386 }
1387 //addMemberToGroup(md,groupId);
1388}
1389
1391{
1392 MemberList *ml = getMemberList(lt);
1393 if (ml) ml->remove(md);
1394}
1395
1397{
1398 removeMemberFromList(MemberListType::AllMembersList(),md);
1399 switch(md->memberType())
1400 {
1402 if (md->getLanguage() == SrcLangExt::Python)
1403 {
1404 removeMemberFromList(MemberListType::PropertyMembers(),md);
1405 removeMemberFromList(MemberListType::Properties(),md);
1406 break;
1407 }
1408 // fallthrough, explicitly no break here
1410 removeMemberFromList(MemberListType::DecVarMembers(),md);
1411 removeMemberFromList(MemberListType::DocVarMembers(),md);
1412 break;
1414 removeMemberFromList(MemberListType::DecFuncMembers(),md);
1415 removeMemberFromList(MemberListType::DocFuncMembers(),md);
1416 break;
1418 removeMemberFromList(MemberListType::DecTypedefMembers(),md);
1419 removeMemberFromList(MemberListType::DocTypedefMembers(),md);
1420 break;
1422 removeMemberFromList(MemberListType::DecSequenceMembers(),md);
1423 removeMemberFromList(MemberListType::DocSequenceMembers(),md);
1424 break;
1426 removeMemberFromList(MemberListType::DecDictionaryMembers(),md);
1427 removeMemberFromList(MemberListType::DocDictionaryMembers(),md);
1428 break;
1430 removeMemberFromList(MemberListType::DecEnumMembers(),md);
1431 removeMemberFromList(MemberListType::DocEnumMembers(),md);
1432 break;
1433 case MemberType::EnumValue: // enum values are shown inside their enums
1434 break;
1435 case MemberType::Define:
1436 removeMemberFromList(MemberListType::DecDefineMembers(),md);
1437 removeMemberFromList(MemberListType::DocDefineMembers(),md);
1438 break;
1439 default:
1440 err("FileDefImpl::removeMember(): unexpected member remove in file!\n");
1441 }
1442}
1443
1444/*! Adds compound definition \a cd to the list of all compounds of this file */
1446{
1447 if (cd->isHidden()) return;
1448
1450
1451 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
1452 {
1454 {
1455 list = &m_interfaces;
1456 }
1457 else if (cd->compoundType()==ClassDef::Struct)
1458 {
1459 list = &m_structs;
1460 }
1461 else if (cd->compoundType()==ClassDef::Exception)
1462 {
1463 list = &m_exceptions;
1464 }
1465 }
1466
1467 list->add(cd->name(),cd);
1468}
1469
1471{
1472 if (cd->isHidden()) return;
1473 m_concepts.add(cd->name(),cd);
1474}
1475
1476/*! Adds namespace definition \a nd to the list of all compounds of this file */
1478{
1479 if (nd->isHidden()) return;
1480 m_namespaces.add(nd->name(),nd);
1481}
1482
1484{
1485 if (Config_getBool(FULL_PATH_NAMES))
1486 return m_fileName;
1487 else
1488 return DefinitionMixin::name();
1489}
1490
1491void FileDefImpl::addSourceRef(int line,const Definition *d,const MemberDef *md)
1492{
1493 //printf("FileDefImpl::addSourceRef(%d,%s,%s)\n",line,qPrint(d?d->name():"nullptr"),qPrint(md?md->name():"nullptr"));
1494 if (d)
1495 {
1496 m_srcDefMap.emplace(line,d);
1497 if (md) m_srcMemberMap.emplace(line,md);
1498 //printf("Adding member %s with anchor %s at line %d to file %s\n",
1499 // md?qPrint(md->name()):"<none>",md?qPrint(md->anchor()):"<none>",line,qPrint(name()));
1500 }
1501}
1502
1504{
1505 auto it = m_srcDefMap.find(lineNr);
1506 //printf("%s::getSourceDefinition(%d)=%s\n",qPrint(name()),lineNr,it!=m_srcDefMap.end()?qPrint(it->second->name()):"none");
1507 return it!=m_srcDefMap.end() ? it->second : nullptr;
1508}
1509
1511{
1512 auto it = m_srcMemberMap.find(lineNr);
1513 //printf("%s::getSourceMember(%d)=%s\n",qPrint(name()),lineNr,it!=m_srcMemberMap.end()?qPrint(it->second->name()):"none");
1514 return it!=m_srcMemberMap.end() ? it->second : nullptr;
1515}
1516
1517
1519{
1520 m_usingDirList.add(nd->qualifiedName(),nd);
1521 //printf("%p: FileDefImpl::addUsingDirective: %s:%d\n",this,qPrint(name()),usingDirList->count());
1522}
1523
1525{
1526 //printf("%p: FileDefImpl::getUsedNamespace: %s:%d\n",this,qPrint(name()),usingDirList?usingDirList->count():0);
1527 return m_usingDirList;
1528}
1529
1534
1536{
1537 //printf("FileDefImpl::addIncludeDependency(%p,%s,%d)\n",(void*)fd,qPrint(incName),kind);
1538 QCString iName = fd ? fd->absFilePath() : incName;
1539 if (!iName.isEmpty() && m_includeMap.find(iName.str())==m_includeMap.end())
1540 {
1541 m_includeList.emplace_back(fd,incName,kind);
1542 m_includeMap.emplace(iName.str(),&m_includeList.back());
1543 }
1544}
1545
1547{
1548 if (visitedFiles.find(this)!=visitedFiles.end()) return; // file already processed
1549 visitedFiles.insert(this);
1550 //printf("( FileDefImpl::addIncludedUsingDirectives for file %s\n",qPrint(name()));
1551
1552 if (!m_includeList.empty()) // file contains #includes
1553 {
1554 {
1555 for (const auto &ii : m_includeList) // foreach #include...
1556 {
1557 if (ii.fileDef) // ...that is a known file
1558 {
1559 // recurse into this file
1560 const_cast<FileDef*>(ii.fileDef)->addIncludedUsingDirectives(visitedFiles);
1561 }
1562 }
1563 }
1564 {
1565 // iterate through list from last to first
1566 for (auto ii_it = m_includeList.rbegin(); ii_it!=m_includeList.rend(); ++ii_it)
1567 {
1568 auto &ii = *ii_it;
1569 if (ii.fileDef && ii.fileDef!=this)
1570 {
1571 // add using directives
1572 auto unl = ii.fileDef->getUsedNamespaces();
1573 for (auto it = unl.rbegin(); it!=unl.rend(); ++it)
1574 {
1575 auto *nd = *it;
1576 //printf(" adding using directive for %s\n",qPrint(nd->qualifiedName()));
1577 m_usingDirList.prepend(nd->qualifiedName(),nd);
1578 }
1579 // add using declarations
1580 auto udl = ii.fileDef->getUsedDefinitions();
1581 for (auto it = udl.rbegin(); it!=udl.rend(); ++it)
1582 {
1583 auto *d = *it;
1584 m_usingDeclList.prepend(d->qualifiedName(),d);
1585 }
1586 }
1587 }
1588 }
1589 }
1590 //printf(") end FileDefImpl::addIncludedUsingDirectives for file %s\n",qPrint(name()));
1591}
1592
1593
1595{
1596 //printf("FileDefImpl::addIncludedByDependency(%p,%s,%d)\n",fd,incName,local);
1597 QCString iName = fd ? fd->absFilePath() : incName;
1598 if (!iName.isEmpty() && m_includedByMap.find(iName.str())==m_includedByMap.end())
1599 {
1600 m_includedByList.emplace_back(fd,incName,kind);
1601 m_includedByMap.emplace(iName.str(),&m_includedByList.back());
1602 }
1603}
1604
1606{
1607 if (name.isEmpty()) return FALSE;
1608 return m_includeMap.find(name.str())!=m_includeMap.end();
1609}
1610
1612{
1613 bool sourceBrowser = Config_getBool(SOURCE_BROWSER);
1614 bool verbatimHeaders = Config_getBool(VERBATIM_HEADERS);
1615 return !isReference() &&
1616 (sourceBrowser ||
1617 (verbatimHeaders && (guessSection(name()).isHeader() || !m_includedByMap.empty()))
1618 ) &&
1620}
1621
1622
1624{
1625 {
1626 const RefItemVector &xrefItems = xrefListItems();
1627 addRefItem(xrefItems,
1629 theTranslator->trFile(TRUE,TRUE),
1631 QCString(),
1632 nullptr
1633 );
1634 }
1635 for (const auto &mg : m_memberGroups)
1636 {
1637 mg->addListReferences(this);
1638 }
1639 for (auto &ml : m_memberLists)
1640 {
1641 if (ml->listType().isDocumentation())
1642 {
1643 ml->addListReferences(this);
1644 }
1645 }
1646}
1647
1648//-------------------------------------------------------------------
1649
1651{
1653 NamespaceDefSet visitedNamespaces;
1654 for (auto &nd : usingDirList)
1655 {
1657 if (ndm)
1658 {
1659 ndm->combineUsingRelations(visitedNamespaces);
1660 }
1661 }
1662
1663 for (auto &nd : usingDirList)
1664 {
1665 // add used namespaces of namespace nd to this namespace
1666 for (const auto &und : nd->getUsedNamespaces())
1667 {
1668 addUsingDirective(und);
1669 }
1670 // add used classes of namespace nd to this namespace
1671 for (const auto &ud : nd->getUsedDefinitions())
1672 {
1674 }
1675 }
1676}
1677
1679{
1680 static const std::unordered_set<std::string> docExtensions =
1681 { "doc", "txt", "dox", "md", "markdown" };
1682
1683 int lastDot = name().findRev('.');
1684 return (lastDot!=-1 && docExtensions.find(name().mid(lastDot+1).str())!=docExtensions.end()) ||
1685 getLanguageFromFileName(getFileNameExtension(name())) == SrcLangExt::Markdown;
1686}
1687
1689{
1690 QCString vercmd = Config_getString(FILE_VERSION_FILTER);
1691 if (!vercmd.isEmpty() && !m_filePath.isEmpty() && !isReference() &&
1692 m_filePath!="generated" && m_filePath!="graph_legend.dox")
1693 {
1694 msg("Version of {} : ",m_filePath);
1695 QCString cmd = vercmd+" \""+m_filePath+"\"";
1696 Debug::print(Debug::ExtCmd,0,"Executing popen(`{}`)\n",cmd);
1697 FILE *f=Portable::popen(cmd,"r");
1698 if (!f)
1699 {
1700 err("could not execute {}\n",vercmd);
1701 return;
1702 }
1703 const int bufSize=1024;
1704 char buf[bufSize];
1705 int numRead = static_cast<int>(fread(buf,1,bufSize-1,f));
1707 if (numRead>0 && numRead<bufSize)
1708 {
1709 buf[numRead]='\0';
1710 m_fileVersion=QCString(buf,numRead).stripWhiteSpace();
1711 if (!m_fileVersion.isEmpty())
1712 {
1713 msg("{}\n",m_fileVersion);
1714 return;
1715 }
1716 }
1717 msg("no version available\n");
1718 }
1719}
1720
1721
1723{
1724 if (Htags::useHtags)
1725 {
1727 }
1728 else
1729 {
1730 return m_outputDiskName+"_source";
1731 }
1732}
1733
1738
1739/*! Returns the name of the verbatim copy of this file (if any). */
1741{
1742 return getSourceFileBase();
1743}
1744
1746{
1747 bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);
1748 bool sortMemberDocs = Config_getBool(SORT_MEMBER_DOCS);
1749 const auto &ml = m_memberLists.get(lt,MemberListContainer::File);
1750 ml->setNeedsSorting(
1751 (ml->listType().isDeclaration() && sortBriefDocs) ||
1752 (ml->listType().isDocumentation() && sortMemberDocs));
1753 ml->push_back(md);
1754 if (ml->listType().isDeclaration())
1755 {
1757 if (mdm)
1758 {
1759 mdm->setSectionList(this,ml.get());
1760 }
1761 }
1762}
1763
1765{
1766 for (auto &ml : m_memberLists)
1767 {
1768 if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
1769 }
1770
1771 for (const auto &mg : m_memberGroups)
1772 {
1773 MemberList &mlg = const_cast<MemberList&>(mg->members());
1774 if (mlg.needsSorting()) { mlg.sort(); mlg.setNeedsSorting(FALSE); }
1775 }
1776
1777 std::stable_sort(m_includedByList.begin(),m_includedByList.end(),
1778 [](const auto &fi1,const auto &fi2) { return fi1.includeName < fi2.includeName; });
1779
1780 if (Config_getBool(SORT_BRIEF_DOCS))
1781 {
1782 auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
1783 {
1784 return Config_getBool(SORT_BY_SCOPE_NAME) ?
1785 qstricmp_sort(c1->name(), c2->name())<0 :
1786 qstricmp_sort(c1->className(), c2->className())<0;
1787 };
1788
1789 std::stable_sort(m_classes.begin(), m_classes.end(), classComp);
1790 std::stable_sort(m_interfaces.begin(),m_interfaces.end(),classComp);
1791 std::stable_sort(m_structs.begin(), m_structs.end(), classComp);
1792 std::stable_sort(m_exceptions.begin(),m_exceptions.end(),classComp);
1793
1794 auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
1795 {
1796 return qstricmp_sort(c1->name(),c2->name())<0;
1797 };
1798
1799 std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
1800
1801 auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
1802 {
1803 return qstricmp_sort(n1->name(),n2->name())<0;
1804 };
1805
1806 std::stable_sort(m_namespaces.begin(),m_namespaces.end(),namespaceComp);
1807 }
1808}
1809
1811{
1812 for (auto &ml : m_memberLists)
1813 {
1814 if (ml->listType()==lt)
1815 {
1816 return ml.get();
1817 }
1818 }
1819 return nullptr;
1820}
1821
1823{
1824 bool optVhdl = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
1825 MemberList * ml = getMemberList(lt);
1826 if (ml)
1827 {
1828 if (optVhdl) // use specific declarations function
1829 {
1830
1831 VhdlDocGen::writeVhdlDeclarations(ml,ol,nullptr,nullptr,this,nullptr,nullptr);
1832 }
1833 else
1834 {
1835 ml->writeDeclarations(ol,nullptr,nullptr,this,nullptr,nullptr,title,QCString());
1836 }
1837 }
1838}
1839
1841{
1842 MemberList * ml = getMemberList(lt);
1843 if (ml) ml->writeDocumentation(ol,name(),this,title,ml->listType().toLabel());
1844}
1845
1847{
1848 bool showFiles = Config_getBool(SHOW_FILES);
1849 return hasDocumentation() && !isReference() && (showFiles || isLinkableViaGroup());
1850}
1851
1853 StringUnorderedSet &filesVisited,const FileDef *fd,StringVector &incFiles)
1854{
1855 for (const auto &ii : fd->includeFileList())
1856 {
1857 if (ii.fileDef && !ii.fileDef->isReference() &&
1858 filesVisited.find(ii.fileDef->absFilePath().str())==filesVisited.end())
1859 {
1860 //printf("FileDefImpl::addIncludeDependency(%s)\n",qPrint(ii->fileDef->absFilePath()));
1861 incFiles.push_back(ii.fileDef->absFilePath().str());
1862 filesVisited.insert(ii.fileDef->absFilePath().str());
1863 getAllIncludeFilesRecursively(filesVisited,ii.fileDef,incFiles);
1864 }
1865 }
1866}
1867
1869{
1870 StringUnorderedSet includes;
1871 ::getAllIncludeFilesRecursively(includes,this,incFiles);
1872}
1873
1875{
1876 if (Config_getBool(HIDE_COMPOUND_REFERENCE))
1877 {
1878 return name();
1879 }
1880 else
1881 {
1882 return theTranslator->trFileReference(name());
1883 }
1884}
1885
1887{
1888 return m_fileVersion;
1889}
1890
1895
1900
1902{
1903 for (auto &ml : m_memberLists)
1904 {
1905 ml->countDecMembers();
1906 ml->countDocMembers();
1907 }
1908 for (const auto &mg : m_memberGroups)
1909 {
1910 mg->countDecMembers();
1911 mg->countDocMembers();
1912 }
1913}
1914
1916{
1917 MemberList *ml = getMemberList(MemberListType::AllMembersList());
1918 return ml ? ml->numDocMembers() : 0;
1919}
1920
1922{
1923 MemberList *ml = getMemberList(MemberListType::AllMembersList());
1924 return ml ? ml->numDecMembers() : 0;
1925}
1926
1931
1936
1938{
1939 return m_hasIncludeGraph;
1940}
1941
1943{
1944 return m_hasIncludedByGraph;
1945}
1946
1947// -----------------------
1948
1949bool compareFileDefs(const FileDef *fd1, const FileDef *fd2)
1950{
1951 return qstricmp_sort(fd1->name(),fd2->name()) < 0;
1952}
1953
1954// --- Cast functions
1955
1957{
1958 if (d==nullptr) return nullptr;
1959 if (d && typeid(*d)==typeid(FileDefImpl))
1960 {
1961 return static_cast<FileDef*>(d);
1962 }
1963 else
1964 {
1965 return nullptr;
1966 }
1967}
1968
1970{
1971 if (d==nullptr) return nullptr;
1972 if (d && typeid(*d)==typeid(FileDefImpl))
1973 {
1974 return static_cast<const FileDef*>(d);
1975 }
1976 else
1977 {
1978 return nullptr;
1979 }
1980}
1981
Clang parser object for a single translation unit, which consists of a source file and the directly o...
Definition clangparser.h:25
A abstract class representing of a compound symbol.
Definition classdef.h:104
virtual QCString className() const =0
Returns the name of the class including outer classes, but not including namespaces.
@ Interface
Definition classdef.h:112
@ Exception
Definition classdef.h:115
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e.
void writeDeclaration(OutputList &ol, const ClassDef::CompoundType *filter, const QCString &header, bool localNames) const
Definition classlist.cpp:53
@ ExtCmd
Definition debug.h:36
static void print(DebugMask mask, int prio, fmt::format_string< Args... > fmt, Args &&... args)
Definition debug.h:76
The common base class of all entity definitions found in the sources.
Definition definition.h:76
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
virtual bool isLinkable() const =0
virtual bool isHidden() const =0
virtual QCString getReference() const =0
virtual QCString qualifiedName() const =0
virtual QCString getOutputFileBase() const =0
virtual bool isReference() const =0
virtual const QCString & name() const =0
bool isReference() const override
const QCString & name() const override
bool isLinkableViaGroup() const override
bool hasBriefDescription() const override
QCString docFile() const override
QCString getDefFileExtension() const override
QCString briefFile() const override
void setLanguage(SrcLangExt lang) override
void setReference(const QCString &r) override
const RefItemVector & xrefListItems() const override
QCString briefDescription(bool abbreviate=FALSE) const override
DefinitionMixin(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const char *b=nullptr, const char *d=nullptr, bool isSymbol=TRUE)
const QCString & localName() const override
const FileDef * getBodyDef() const override
int getStartBodyLine() const override
QCString inbodyDocumentation() const override
int docLine() const override
int briefLine() const override
QCString documentation() const override
void writeDocAnchorsToTagFile(TextStream &fs) const override
bool hasDocumentation() const override
SrcLangExt getLanguage() const override
virtual void writeNavigationPath(OutputList &ol) const =0
Class implementing OutputCodeIntf by throwing away everything.
Definition devnullgen.h:21
A model of a directory symbol.
Definition dirdef.h:110
Representation of an include dependency graph.
bool isTooBig() const
bool isTrivial() const
static bool suppressDocWarnings
Definition doxygen.h:132
static bool parseSourcesNeeded
Definition doxygen.h:123
static bool clangAssistedParsing
Definition doxygen.h:138
static ParserManager * parserManager
Definition doxygen.h:131
A model of a file symbol.
Definition filedef.h:99
virtual QCString includeName() const =0
virtual bool generateSourceFile() const =0
virtual QCString absFilePath() const =0
virtual const IncludeInfoList & includeFileList() const =0
bool isDocumentationFile() const override
Definition filedef.cpp:1678
void findSectionsInDocumentation() override
Definition filedef.cpp:345
void setModuleDef(ModuleDef *mod) override
Definition filedef.cpp:191
void addIncludedUsingDirectives(FileDefSet &visitedFiles) override
Definition filedef.cpp:1546
void writeBriefDescription(OutputList &ol)
Definition filedef.cpp:543
const LinkedRefMap< const Definition > & getUsedDefinitions() const override
Definition filedef.cpp:155
void setDiskName(const QCString &name) override
Definition filedef.cpp:324
void addSourceRef(int line, const Definition *d, const MemberDef *md) override
Definition filedef.cpp:1491
LinkedRefMap< const Definition > m_usingDeclList
Definition filedef.cpp:241
DirDef * m_dir
Definition filedef.cpp:253
QCString getOutputFileBase() const override
Definition filedef.cpp:1734
void insertNamespace(NamespaceDef *nd) override
Definition filedef.cpp:1477
ModuleDef * getModuleDef() const override
Definition filedef.cpp:153
void writeQuickMemberLinks(OutputList &ol, const MemberDef *currentMd) const override
Definition filedef.cpp:1111
void writeSourceLink(OutputList &ol)
Definition filedef.cpp:699
void writeSummaryLinks(OutputList &ol) const override
Definition filedef.cpp:798
QCString absFilePath() const override
Definition filedef.cpp:141
QCString m_path
Definition filedef.cpp:242
ClassLinkedRefMap m_interfaces
Definition filedef.cpp:259
const ConceptLinkedRefMap & getConcepts() const override
Definition filedef.cpp:163
QCString m_inclDepFileName
Definition filedef.cpp:244
ClassLinkedRefMap m_structs
Definition filedef.cpp:260
void sortMemberLists() override
Definition filedef.cpp:1764
void parseSource(ClangTUParser *clangParser) override
Definition filedef.cpp:1272
void setDiskNameLocal(const QCString &name)
Definition filedef.cpp:308
void addMemberToList(MemberListType lt, MemberDef *md)
Definition filedef.cpp:1745
void acquireFileVersion()
Definition filedef.cpp:1688
QCString m_fileVersion
Definition filedef.cpp:252
void addUsingDirective(NamespaceDef *nd) override
Definition filedef.cpp:1518
void writeNamespaceDeclarations(OutputList &ol, const QCString &title, bool isConstantGroup)
Definition filedef.cpp:714
void countMembers() override
Definition filedef.cpp:1901
void distributeMemberGroupDocumentation() override
Definition filedef.cpp:336
MemberDefLineMap m_srcMemberMap
Definition filedef.cpp:250
ConceptLinkedRefMap m_concepts
Definition filedef.cpp:262
void insertClass(ClassDef *cd) override
Definition filedef.cpp:1445
DefinitionLineMap m_srcDefMap
Definition filedef.cpp:249
QCString getSourceFileBase() const override
Definition filedef.cpp:1722
NamespaceLinkedRefMap m_namespaces
Definition filedef.cpp:257
ModuleDef * m_moduleDef
Definition filedef.cpp:254
IncludeInfoList m_includedByList
Definition filedef.cpp:239
CodeSymbolType codeSymbolType() const override
Definition filedef.cpp:130
void writeClassDeclarations(OutputList &ol, const QCString &title, const ClassLinkedRefMap &list)
Definition filedef.cpp:721
QCString anchor() const override
Definition filedef.cpp:136
bool m_hasIncludeGraph
Definition filedef.cpp:264
const NamespaceLinkedRefMap & getNamespaces() const override
Definition filedef.cpp:162
void removeMember(MemberDef *md) override
Definition filedef.cpp:1396
void addUsingDeclaration(const Definition *d) override
Definition filedef.cpp:1530
ClassLinkedRefMap m_exceptions
Definition filedef.cpp:261
QCString includeName() const override
Definition filedef.cpp:1740
void writeTagFile(TextStream &t) override
Definition filedef.cpp:374
void endMemberDeclarations(OutputList &ol)
Definition filedef.cpp:751
void addListReferences() override
Definition filedef.cpp:1623
void writeMemberDeclarations(OutputList &ol, MemberListType lt, const QCString &title)
Definition filedef.cpp:1822
const MemberGroupList & getMemberGroups() const override
Definition filedef.cpp:161
IncludeInfoMap m_includedByMap
Definition filedef.cpp:238
void insertMember(MemberDef *md) override
Definition filedef.cpp:1322
const LinkedRefMap< NamespaceDef > & getUsedNamespaces() const override
Definition filedef.cpp:1524
void writeInlineClasses(OutputList &ol)
Definition filedef.cpp:733
const QCString & docName() const override
Definition filedef.cpp:142
void writeIncludeFiles(OutputList &ol)
Definition filedef.cpp:599
MemberGroupList m_memberGroups
Definition filedef.cpp:256
void computeAnchors() override
Definition filedef.cpp:330
void writeDetailedDescription(OutputList &ol, const QCString &title)
Definition filedef.cpp:472
QCString m_fileName
Definition filedef.cpp:247
void writeMemberPages(OutputList &ol) override
Definition filedef.cpp:1095
void writeSourceFooter(OutputList &ol) override
Definition filedef.cpp:1265
QCString fileVersion() const override
Definition filedef.cpp:1886
void writeConcepts(OutputList &ol, const QCString &title)
Definition filedef.cpp:727
bool generateSourceFile() const override
Definition filedef.cpp:1611
void writeIncludedByGraph(OutputList &ol)
Definition filedef.cpp:673
const QCString & name() const override
Definition filedef.cpp:1483
bool m_isSource
Definition filedef.cpp:251
const MemberDef * getSourceMember(int lineNr) const override
Definition filedef.cpp:1510
QCString m_outputDiskName
Definition filedef.cpp:246
bool isIncluded(const QCString &name) const override
Definition filedef.cpp:1605
~FileDefImpl() override
Definition filedef.cpp:304
const IncludeInfoList & includeFileList() const override
Definition filedef.cpp:156
void removeMemberFromList(MemberListType lt, MemberDef *md)
Definition filedef.cpp:1390
void getAllIncludeFilesRecursively(StringVector &incFiles) const override
Definition filedef.cpp:1868
MemberLists m_memberLists
Definition filedef.cpp:255
LinkedRefMap< NamespaceDef > m_usingDirList
Definition filedef.cpp:240
QCString getVersion() const override
Definition filedef.cpp:148
void writeAuthorSection(OutputList &ol)
Definition filedef.cpp:786
void insertConcept(ConceptDef *cd) override
Definition filedef.cpp:1470
const MemberLists & getMemberLists() const override
Definition filedef.cpp:160
void addIncludedByDependency(const FileDef *fd, const QCString &incName, IncludeKind kind) override
Definition filedef.cpp:1594
IncludeInfoMap m_includeMap
Definition filedef.cpp:236
bool m_subGrouping
Definition filedef.cpp:263
QCString m_inclByDepFileName
Definition filedef.cpp:245
DirDef * getDirDef() const override
Definition filedef.cpp:152
void overrideIncludeGraph(bool e) override
Definition filedef.cpp:1927
ClassLinkedRefMap m_classes
Definition filedef.cpp:258
QCString m_docname
Definition filedef.cpp:248
void overrideIncludedByGraph(bool e) override
Definition filedef.cpp:1932
const IncludeInfoList & includedByFileList() const override
Definition filedef.cpp:157
bool hasIncludedByGraph() const override
Definition filedef.cpp:1942
void writePageNavigation(OutputList &ol) const override
Definition filedef.cpp:864
QCString displayName(bool=TRUE) const override
Definition filedef.cpp:133
bool subGrouping() const override
Definition filedef.cpp:168
QCString m_filePath
Definition filedef.cpp:243
void writeMemberDocumentation(OutputList &ol, MemberListType lt, const QCString &title)
Definition filedef.cpp:1840
void writeSourceHeader(OutputList &ol) override
Definition filedef.cpp:1155
FileDefImpl(const QCString &p, const QCString &n, const QCString &ref=QCString(), const QCString &dn=QCString())
Definition filedef.cpp:280
void writeSourceBody(OutputList &ol, ClangTUParser *clangParser) override
Definition filedef.cpp:1208
void writeIncludeGraph(OutputList &ol)
Definition filedef.cpp:648
QCString title() const override
Definition filedef.cpp:1874
void addMembersToMemberGroup() override
Definition filedef.cpp:1300
int numDocMembers() const override
Definition filedef.cpp:1915
QCString getPath() const override
Definition filedef.cpp:147
bool m_hasIncludedByGraph
Definition filedef.cpp:265
IncludeInfoList m_includeList
Definition filedef.cpp:237
void startMemberDocumentation(OutputList &ol)
Definition filedef.cpp:756
int numDecMembers() const override
Definition filedef.cpp:1921
void writeClassesToTagFile(TextStream &t, const ClassLinkedRefMap &list)
Definition filedef.cpp:587
MemberList * getMemberList(MemberListType lt) const override
Definition filedef.cpp:1810
void startMemberDeclarations(OutputList &ol)
Definition filedef.cpp:746
bool isSource() const override
Definition filedef.cpp:143
void combineUsingRelations() override
Definition filedef.cpp:1650
bool isLinkableInProject() const override
Definition filedef.cpp:1846
void endMemberDocumentation(OutputList &ol)
Definition filedef.cpp:765
QCString includedByDependencyGraphFileName() const override
Definition filedef.cpp:1896
const ClassLinkedRefMap & getClasses() const override
Definition filedef.cpp:164
QCString fileName() const override
Definition filedef.cpp:134
bool hasIncludeGraph() const override
Definition filedef.cpp:1937
void writeDocumentation(OutputList &ol) override
Definition filedef.cpp:872
bool isLinkable() const override
Definition filedef.cpp:150
void addIncludeDependency(const FileDef *fd, const QCString &incName, IncludeKind kind) override
Definition filedef.cpp:1535
DefType definitionType() const override
Definition filedef.cpp:129
bool hasDetailedDescription() const override
Definition filedef.cpp:364
QCString includeDependencyGraphFileName() const override
Definition filedef.cpp:1891
void setDirDef(DirDef *dd) override
Definition filedef.cpp:190
void writeMemberGroups(OutputList &ol)
Definition filedef.cpp:774
const Definition * getSourceDefinition(int lineNr) const override
Definition filedef.cpp:1503
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition layout.cpp:1437
Container class representing a vector of objects with keys.
Definition linkedmap.h:232
bool add(const char *k, T *obj)
Definition linkedmap.h:284
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
virtual const ClassDef * getClassDef() const =0
virtual MemberType memberType() const =0
virtual void setSectionList(const Definition *container, const MemberList *sl)=0
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:125
bool needsSorting() const
Definition memberlist.h:140
int numDocMembers() const
Definition memberlist.h:138
void writeDeclarations(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, const QCString &title, const QCString &subtitle, bool showEnumValues=FALSE, bool showInline=FALSE, const ClassDef *inheritedFrom=nullptr, MemberListType lt=MemberListType::PubMethods(), bool showSectionTitle=true) const
Writes the list of members to the output.
void writeTagFile(TextStream &, bool useQualifiedName=false, bool showNamespaceMembers=true)
void setNeedsSorting(bool b)
MemberListType listType() const
Definition memberlist.h:130
void writeDocumentation(OutputList &ol, const QCString &scopeName, const Definition *container, const QCString &title, const QCString &anchor, bool showEnumValues=FALSE, bool showInline=FALSE) const
void setAnchors()
int numDecMembers(const ClassDef *inheritedFrom) const
Definition memberlist.h:133
bool declVisible() const
Wrapper class for the MemberListType type.
Definition types.h:346
constexpr const char * toLabel() const noexcept
Definition types.h:402
void remove(const MemberDef *md)
Definition memberlist.h:84
void sort()
Definition memberlist.h:76
bool contains(const MemberDef *md) const
Definition memberlist.h:89
void push_back(const T &value)
Definition memberlist.h:48
static ModuleManager & instance()
ModuleDef * getPrimaryInterface(const QCString &moduleName) const
An abstract interface of a namespace symbol.
virtual void combineUsingRelations(NamespaceDefSet &visitedNamespace)=0
Class representing a list of different code generators.
Definition outputlist.h:165
void add(OutputCodeIntfPtr &&p)
Definition outputlist.h:195
void startCodeFragment(const QCString &style)
Definition outputlist.h:279
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:315
void writeDoc(const IDocNodeAST *ast, const Definition *ctx, const MemberDef *md, int sectionLevel=-1)
Definition outputlist.h:383
bool isEnabled(OutputType o)
void endTextBlock(bool paraBreak=FALSE)
Definition outputlist.h:672
void writeString(const QCString &text)
Definition outputlist.h:411
void disable(OutputType o)
void startInclDepGraph()
Definition outputlist.h:652
void writeRuler()
Definition outputlist.h:521
const OutputCodeList & codeGenerators() const
Definition outputlist.h:358
void startGroupHeader(const QCString &id=QCString(), int extraLevels=0)
Definition outputlist.h:453
void enable(OutputType o)
void endContents()
Definition outputlist.h:620
void writeObjectLink(const QCString &ref, const QCString &file, const QCString &anchor, const QCString &name)
Definition outputlist.h:439
void docify(const QCString &s)
Definition outputlist.h:437
void generateDoc(const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, const DocOptions &options)
void startParagraph(const QCString &classDef=QCString())
Definition outputlist.h:407
void startProjectNumber()
Definition outputlist.h:391
void startTextBlock(bool dense=FALSE)
Definition outputlist.h:670
void endParagraph()
Definition outputlist.h:409
void endInclDepGraph(DotInclDepGraph &g)
Definition outputlist.h:654
void startMemberSections()
Definition outputlist.h:461
void endTextLink()
Definition outputlist.h:444
void writeSynopsis()
Definition outputlist.h:592
void startTypewriter()
Definition outputlist.h:449
void pushGeneratorState()
void disableAllBut(OutputType o)
void popGeneratorState()
void writeSummaryLink(const QCString &file, const QCString &anchor, const QCString &title, bool first)
Definition outputlist.h:614
void writeAnchor(const QCString &fileName, const QCString &name)
Definition outputlist.h:523
void endGroupHeader(int extraLevels=0)
Definition outputlist.h:455
void endQuickIndices()
Definition outputlist.h:604
void writePageOutline()
Definition outputlist.h:616
void startContents()
Definition outputlist.h:618
void enableAll()
void endProjectNumber()
Definition outputlist.h:393
void endTypewriter()
Definition outputlist.h:451
void lineBreak(const QCString &style=QCString())
Definition outputlist.h:559
void parseText(const QCString &textStr)
void startTextLink(const QCString &file, const QCString &anchor)
Definition outputlist.h:442
void endMemberSections()
Definition outputlist.h:463
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
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:166
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:260
const std::string & str() const
Definition qcstring.h:552
QCString right(size_t len) const
Definition qcstring.h:234
QCString & sprintf(const char *format,...)
Definition qcstring.cpp:29
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition qcstring.cpp:96
QCString & insert(size_t index, const QCString &s)
Definition qcstring.h:332
QCString left(size_t len) const
Definition qcstring.h:229
Text streaming class that buffers data.
Definition textstream.h:36
static void writeVhdlDeclarations(const MemberList *, OutputList &, const GroupDef *, const ClassDef *, const FileDef *, const NamespaceDef *, const ModuleDef *)
#define Config_getInt(name)
Definition config.h:34
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
#define NON_COPYABLE(cls)
Macro to help implementing the rule of 5 for a non-copyable & movable class.
Definition construct.h:37
std::unordered_set< std::string > StringUnorderedSet
Definition containers.h:29
std::vector< std::string > StringVector
Definition containers.h:33
void docFindSections(const QCString &input, const Definition *d, const QCString &fileName)
IDocNodeASTPtr validatingParseDoc(IDocParser &parserIntf, const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &input, const DocOptions &options)
IDocParserPtr createDocParser()
factory function to create a parser
Definition docparser.cpp:55
static void writeTagFile()
std::unordered_map< std::string, const IncludeInfo * > IncludeInfoMap
Definition filedef.cpp:120
QCString includeClose(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:86
std::unordered_map< int, const Definition * > DefinitionLineMap
Definition filedef.cpp:118
QCString includeStatement(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:56
std::unique_ptr< FileDef > createFileDef(const QCString &p, const QCString &n, const QCString &ref, const QCString &dn)
Definition filedef.cpp:268
bool compareFileDefs(const FileDef *fd1, const FileDef *fd2)
Definition filedef.cpp:1949
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1956
std::unordered_map< int, const MemberDef * > MemberDefLineMap
Definition filedef.cpp:119
QCString includeOpen(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:73
QCString includeTagFileAttributes(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:104
static void getAllIncludeFilesRecursively(StringUnorderedSet &filesVisited, const FileDef *fd, StringVector &incFiles)
Definition filedef.cpp:1852
constexpr uint32_t IncludeKind_ObjCMask
Definition filedef.h:67
IncludeKind
Definition filedef.h:47
@ ImportLocal
Definition filedef.h:54
@ ImportModule
Definition filedef.h:55
@ IncludeLocal
Definition filedef.h:50
@ ImportSystemObjC
Definition filedef.h:51
@ ImportLocalObjC
Definition filedef.h:52
@ IncludeSystem
Definition filedef.h:49
@ ImportSystem
Definition filedef.h:53
constexpr uint32_t IncludeKind_ImportMask
Definition filedef.h:65
constexpr uint32_t IncludeKind_LocalMask
Definition filedef.h:63
std::unordered_set< const FileDef * > FileDefSet
Definition filedef.h:44
void startTitle(OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
Definition index.cpp:384
void endTitle(OutputList &ol, const QCString &fileName, const QCString &name)
Definition index.cpp:394
void startFile(OutputList &ol, const QCString &name, bool isSource, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName, int hierarchyLevel, const QCString &allMembersFile)
Definition index.cpp:401
void endFileWithNavPath(OutputList &ol, const DefinitionMutable *d, bool showPageNavigation)
Definition index.cpp:448
Translator * theTranslator
Definition language.cpp:71
MemberDefMutable * toMemberDefMutable(Definition *d)
#define warn_uncond(fmt,...)
Definition message.h:122
#define msg(fmt,...)
Definition message.h:94
#define err(fmt,...)
Definition message.h:127
FILE * popen(const QCString &name, const QCString &type)
Definition portable.cpp:480
int pclose(FILE *stream)
Definition portable.cpp:489
NamespaceDefMutable * toNamespaceDefMutable(Definition *d)
std::unordered_set< const NamespaceDef * > NamespaceDefSet
Portable versions of functions that are platform dependent.
int qstricmp_sort(const char *str1, const char *str2)
Definition qcstring.h:86
const char * qPrint(const char *s)
Definition qcstring.h:687
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34
std::vector< RefItem * > RefItemVector
Definition reflist.h:133
Web server based search engine.
std::string_view stripWhiteSpace(std::string_view s)
Given a string view s, returns a new, narrower view on that string, skipping over any leading or trai...
Definition stringutil.h:72
static QCString path2URL(const QCString &path)
Definition htags.cpp:157
static bool useHtags
Definition htags.h:23
Represents of a member declaration list with configurable title and subtitle.
Definition layout.h:112
QCString title(SrcLangExt lang) const
Definition layout.cpp:1788
MemberListType type
Definition layout.h:118
Represents of a member definition list with configurable title.
Definition layout.h:132
MemberListType type
Definition layout.h:137
QCString title(SrcLangExt lang) const
Definition layout.cpp:1800
Definition layout.h:102
QCString title(SrcLangExt lang) const
Definition layout.cpp:1781
CodeSymbolType
Definition types.h:481
@ Enumeration
Definition types.h:557
@ EnumValue
Definition types.h:558
@ Dictionary
Definition types.h:568
@ 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
SrcLangExt
Definition types.h:207
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5134
QCString convertToHtml(const QCString &s, bool keepEntities)
Definition util.cpp:3900
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:4753
void addGroupListToTitle(OutputList &ol, const Definition *d)
Definition util.cpp:4840
QCString fileToString(const QCString &name, bool filter, bool isSourceCode)
Definition util.cpp:1439
void createSubDirs(const Dir &d)
Definition util.cpp:3577
static QCString stripFromPath(const QCString &p, const StringVector &l)
Definition util.cpp:300
QCString convertNameToFile(const QCString &name, bool allowDots, bool allowUnderscore)
Definition util.cpp:3441
QCString convertToXML(const QCString &s, bool keepEntities)
Definition util.cpp:3849
QCString detab(const QCString &s, size_t &refIndent)
Definition util.cpp:6657
EntryType guessSection(const QCString &name)
Definition util.cpp:340
QCString removeLongPathMarker(QCString path)
Definition util.cpp:289
QCString getFileFilter(const QCString &name, bool isSourceCode)
Definition util.cpp:1367
QCString getFileNameExtension(const QCString &fn)
Definition util.cpp:5176
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:4850
A bunch of utility functions.