Doxygen
Loading...
Searching...
No Matches
memberdef.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// own header
17#include "memberdef.h"
18
19// standard includes
20#include <memory>
21#include <mutex>
22#include <optional>
23
24// other includes
25#include "arguments.h"
26#include "code.h"
27#include "config.h"
28#include "defargs.h"
29#include "definitionimpl.h"
30#include "docparser.h"
31#include "dotcallgraph.h"
32#include "doxygen.h"
33#include "example.h"
34#include "filedef.h"
35#include "groupdef.h"
36#include "language.h"
37#include "md5hash.h"
38#include "membergroup.h"
39#include "memberlist.h"
40#include "membername.h"
41#include "message.h"
42#include "moduledef.h"
43#include "namespacedef.h"
44#include "outputlist.h"
45#include "parserintf.h"
46#include "regex.h"
47#include "trace.h"
48#include "util.h"
49#include "vhdldocgen.h"
50
51//-----------------------------------------------------------------------------
52
53class MemberDefImpl final : public DefinitionMixin<MemberDefMutable>
54{
55 public:
56 MemberDefImpl(const DString &defFileName,int defLine,size_t defColumn,
57 const DString &type,const DString &name,const DString &args,
58 const DString &excp,Protection prot,Specifier virt,bool stat,
59 Relationship related,MemberType t,const ArgumentList &tal,
60 const ArgumentList &al,const DString &metaData);
61 ~MemberDefImpl() override = default;
63
64 DefType definitionType() const override { return TypeMember; }
65 MemberDef *resolveAlias() override { return this; }
66 const MemberDef *resolveAlias() const override { return this; }
67 CodeSymbolType codeSymbolType() const override;
68 std::unique_ptr<MemberDef> deepCopy() const override;
69 void moveTo(Definition *) override;
70 DString getOutputFileBase() const override;
71 DString getReference() const override;
72 DString anchor() const override;
73 DString declaration() const override;
74 DString definition() const override;
75 DString typeString() const override;
76 DString argsString() const override;
77 DString excpString() const override;
78 DString bitfieldString() const override;
79 DString extraTypeChars() const override;
80 const DString &initializer() const override;
81 int initializerLines() const override;
82 TypeSpecifier getMemberSpecifiers() const override;
83 VhdlSpecifier getVhdlSpecifiers() const override;
84 const MemberList *getSectionList(const Definition *) const override;
85 DString displayDefinition() const override;
86 const ClassDef *getClassDef() const override;
87 ClassDef *getClassDef() override;
88 const FileDef *getFileDef() const override;
89 FileDef *getFileDef() override;
90 const NamespaceDef* getNamespaceDef() const override;
91 NamespaceDef* getNamespaceDef() override;
92 const GroupDef *getGroupDef() const override;
93 GroupDef *getGroupDef() override;
94 const ModuleDef *getModuleDef() const override;
95 DString getReadAccessor() const override;
96 DString getWriteAccessor() const override;
97 Grouping::GroupPri_t getGroupPri() const override;
98 DString getGroupFileName() const override;
99 int getGroupStartLine() const override;
100 bool getGroupHasDocs() const override;
101 DString qualifiedName() const override;
102 DString objCMethodName(bool localLink,bool showStatic) const override;
103 Protection protection() const override;
104 Specifier virtualness(int count=0) const override;
105 MemberType memberType() const override;
106 DString memberTypeName() const override;
107 bool isSignal() const override;
108 bool isSlot() const override;
109 bool isVariable() const override;
110 bool isEnumerate() const override;
111 bool isEnumValue() const override;
112 bool isTypedef() const override;
113 bool isSequence() const override;
114 bool isDictionary() const override;
115 bool isFunction() const override;
116 bool isFunctionPtr() const override;
117 bool isDefine() const override;
118 bool isFriend() const override;
119 bool isDCOP() const override;
120 bool isProperty() const override;
121 bool isEvent() const override;
122 bool isRelated() const override;
123 bool isForeign() const override;
124 bool isStatic() const override;
125 bool isInline() const override;
126 bool isExplicit() const override;
127 bool isMutable() const override;
128 bool isThreadLocal() const override;
129 bool isGettable() const override;
130 bool isPrivateGettable() const override;
131 bool isProtectedGettable() const override;
132 bool isSettable() const override;
133 bool isPrivateSettable() const override;
134 bool isProtectedSettable() const override;
135 bool isReadable() const override;
136 bool isWritable() const override;
137 bool isAddable() const override;
138 bool isRemovable() const override;
139 bool isRaisable() const override;
140 bool isFinal() const override;
141 bool isAbstract() const override;
142 bool isOverride() const override;
143 bool isInitonly() const override;
144 bool isOptional() const override;
145 bool isRequired() const override;
146 bool isNonAtomic() const override;
147 bool isCopy() const override;
148 bool isAssign() const override;
149 bool isRetain() const override;
150 bool isWeak() const override;
151 bool isStrong() const override;
152 bool isEnumStruct() const override;
153 bool isUnretained() const override;
154 bool isNew() const override;
155 bool isSealed() const override;
156 bool isImplementation() const override;
157 bool isExternal() const override;
158 bool isTypeAlias() const override;
159 bool isDefault() const override;
160 bool isDelete() const override;
161 bool isNoExcept() const override;
162 bool isAttribute() const override;
163 bool isUNOProperty() const override;
164 bool isReadonly() const override;
165 bool isBound() const override;
166 bool isConstrained() const override;
167 bool isTransient() const override;
168 bool isMaybeVoid() const override;
169 bool isMaybeDefault() const override;
170 bool isMaybeAmbiguous() const override;
171 bool isPublished() const override;
172 bool isTemplateSpecialization() const override;
173 bool isObjCMethod() const override;
174 bool isObjCProperty() const override;
175 bool isCSharpProperty() const override;
176 bool isConstructor() const override;
177 bool isDestructor() const override;
178 bool hasOneLineInitializer() const override;
179 bool hasMultiLineInitializer() const override;
180 bool isCallable() const override;
181 bool isStrongEnumValue() const override;
182 bool livesInsideEnum() const override;
183 bool isSliceLocal() const override;
184 bool isNoDiscard() const override;
185 bool isConstExpr() const override;
186 bool isConstEval() const override;
187 bool isConstInit() const override;
188 int numberOfFlowKeyWords() const override;
189 bool isFriendToHide() const override;
190 bool isNotFriend() const override;
191 bool isFunctionOrSignalSlot() const override;
192 bool isRelatedOrFriend() const override;
193 bool isLinkableInProject() const override;
194 bool isLinkable() const override;
195 bool hasDocumentation() const override;
196 bool hasUserDocumentation() const override;
197 bool isDeleted() const override;
198 bool isBriefSectionVisible() const override;
199 bool isDetailedSectionVisible(MemberListContainer container) const override;
200 bool hasDetailedDescription() const override;
201 bool isFriendClass() const override;
202 bool isDocumentedFriendClass() const override;
203 const MemberDef *reimplements() const override;
204 const MemberVector &reimplementedBy() const override;
205 bool isReimplementedBy(const ClassDef *cd) const override;
206 ClassDef *relatedAlso() const override;
207 bool hasDocumentedEnumValues() const override;
208 const MemberDef *getAnonymousEnumType() const override;
209 const MemberDef *anonymousMemberForDeclaration() const override;
210 const MemberDef *anonymousMemberForDetails() const override;
211 bool isDocsForDefinition() const override;
212 const MemberDef *getEnumScope() const override;
213 const MemberVector &enumFieldList() const override;
214 void setEnumBaseType(const DString &type) override;
215 DString enumBaseType() const override;
216 bool hasExamples() const override;
217 const ExampleList &getExamples() const override;
218 bool isPrototype() const override;
219 const ArgumentList &argumentList() const override;
220 const ArgumentList &declArgumentList() const override;
221 const ArgumentList &templateArguments() const override;
222 const ArgumentLists &definitionTemplateParameterLists() const override;
223 std::optional<ArgumentList> formalTemplateArguments() const override;
224 int getMemberGroupId() const override;
225 MemberGroup *getMemberGroup() const override;
226 bool hasCallGraph() const override;
227 bool hasCallerGraph() const override;
228 bool hasReferencesRelation() const override;
229 bool hasReferencedByRelation() const override;
230 bool hasEnumValues() const override;
231 bool hasInlineSource() const override;
232 bool isDocTransferDone() const override;
233 DString sourceRefName() const override;
234 const MemberDef *templateMaster() const override;
235 DString getScopeString() const override;
236 const ClassDef *getClassDefOfAnonymousType() const override;
237 bool isTypedefValCached() const override;
238 const ClassDef *getCachedTypedefVal() const override;
239 DString getCachedTypedefTemplSpec() const override;
240 DString getCachedResolvedTypedef() const override;
241 MemberDef *memberDefinition() const override;
242 MemberDef *memberDeclaration() const override;
243 const MemberDef *inheritsDocsFrom() const override;
244 const MemberDef *getGroupAlias() const override;
245 ClassDef *category() const override;
246 const MemberDef *categoryRelation() const override;
247 DString displayName(bool=true) const override;
248 DString getDeclType() const override;
249 StringVector getLabels(const Definition *container) const override;
250 const ArgumentList &typeConstraints() const override;
251 DString requiresClause() const override;
252 DString documentation() const override;
253 DString briefDescription(bool abbr=false) const override;
254 DString fieldType() const override;
255 bool isReference() const override;
256 DString getDeclFileName() const override;
257 int getDeclLine() const override;
258 size_t getDeclColumn() const override;
259 void setMemberType(MemberType t) override;
260 void setDefinition(const DString &d) override;
261 void setFileDef(FileDef *fd) override;
262 void setAnchor() override;
263 void setProtection(Protection p) override;
264 void setMemberSpecifiers(TypeSpecifier s) override;
265 void setVhdlSpecifiers(VhdlSpecifier s) override;
266 void mergeMemberSpecifiers(TypeSpecifier s) override;
267 void setInitializer(const DString &i) override;
268 void setBitfields(const DString &s) override;
269 void setMaxInitLines(int lines) override;
270 void setMemberClass(ClassDef *cd) override;
271 void setSectionList(const Definition *container,const MemberList *sl) override;
273 const DString &fileName,int startLine,bool hasDocs,
274 MemberDef *member=nullptr) override;
275 void setReadAccessor(const DString &r) override;
276 void setWriteAccessor(const DString &w) override;
277 void setTemplateSpecialization(bool b) override;
278 void makeRelated() override;
279 void makeForeign() override;
280 void setInheritsDocsFrom(const MemberDef *md) override;
281 void setTagInfo(const TagInfo *i) override;
282 void setArgsString(const DString &as) override;
283 void setReimplements(MemberDef *md) override;
284 void insertReimplementedBy(MemberDef *md) override;
285 void setRelatedAlso(ClassDef *cd) override;
286 void insertEnumField(MemberDef *md) override;
287 void setEnumScope(MemberDef *md,bool livesInsideEnum=false) override;
288 void setEnumClassScope(ClassDef *cd) override;
289 void setDocumentedEnumValues(bool value) override;
290 void setAnonymousEnumType(const MemberDef *md) override;
291 void setAnonymousMemberForDeclaration(const MemberDef *md) override;
292 void setAnonymousMemberForDetails(const MemberDef *md) override;
293 bool addExample(const DString &anchor,const DString &name,const DString &file) override;
294 void setPrototype(bool p,const DString &df,int line, size_t column) override;
295 void setExplicitExternal(bool b,const DString &df,int line,size_t column) override;
296 void setDeclFile(const DString &df,int line,size_t column) override;
297 void moveArgumentList(std::unique_ptr<ArgumentList> al) override;
298 void moveDeclArgumentList(std::unique_ptr<ArgumentList> al) override;
299 void setDefinitionTemplateParameterLists(const ArgumentLists &lists) override;
300 void setTypeConstraints(const ArgumentList &al) override;
301 void setType(const DString &t) override;
302 void setNamespace(NamespaceDef *nd) override;
303 void setMemberGroup(MemberGroup *grp) override;
304 void setMemberGroupId(int id) override;
305 void makeImplementationDetail() override;
306 void overrideCallGraph(bool e) override;
307 void overrideCallerGraph(bool e) override;
308 void overrideReferencedByRelation(bool e) override;
309 void overrideReferencesRelation(bool e) override;
310 void overrideEnumValues(bool e) override;
311 void overrideInlineSource(bool e) override;
312 void setTemplateMaster(const MemberDef *mt) override;
313 void setFormalTemplateArguments(const ArgumentList &al) override;
314 void addListReference(const Definition *) override;
315 void addRequirementReferences(const Definition *) override;
316 void setDocsForDefinition(bool b) override;
317 void setGroupAlias(const MemberDef *md) override;
318 void cacheTypedefVal(const ClassDef *val,const DString &templSpec,const DString &resolvedType) override;
319 void invalidateTypedefValCache() override;
320 void invalidateCachedArgumentTypes() override;
321 void setMemberDefinition(MemberDef *md) override;
322 void setMemberDeclaration(MemberDef *md) override;
323 void copyArgumentNames(const MemberDef *bmd) override;
324 void setCategory(ClassDef *) override;
325 void setCategoryRelation(const MemberDef *) override;
326 void setDocumentation(const DString &d,const DString &docFile,int docLine,bool stripWhiteSpace=true) override;
327 void setBriefDescription(const DString &b,const DString &briefFile,int briefLine) override;
328 void setInbodyDocumentation(const DString &d,const DString &inbodyFile,int inbodyLine) override;
329 void setHidden(bool b) override;
330 void setDocTransferDone() override;
331 void setExplicitInherited(bool b) override;
332 void setRequiresClause(const DString &req) override;
333 void incrementFlowKeyWordCount() override;
335 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
336 bool inGroup, int indentLevel,const ClassDef *inheritFrom=nullptr,const DString &inheritId=DString(),
337 const DString &declAnchor=DString()) const override;
338 void writeDocumentation(const MemberList *ml,int memCount,int memTotal,OutputList &ol,
339 const DString &scopeName,const Definition *container,
340 bool inGroup,bool showEnumValues=false,bool
341 showInline=false) const override;
342 void writeMemberDocSimple(OutputList &ol,const Definition *container) const override;
343 void writeEnumDeclaration(OutputList &typeDecl,
344 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const override;
345 void writeTagFile(TextStream &,bool useQualifiedName,bool showNamespaceMembers) const override;
346 void warnIfUndocumented() const override;
347 void warnIfUndocumentedParams() const override;
348 bool visibleInIndex() const override;
349 void detectUndocumentedParams(bool hasParamCommand,bool hasReturnCommand) const override;
350 std::unique_ptr<MemberDef> createTemplateInstanceMember(const ArgumentList &formalArgs,
351 const std::unique_ptr<ArgumentList> &actualArgs) const override;
352 void findSectionsInDocumentation() override;
353 void writeLink(OutputList &ol,
354 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
355 bool onlyText=false) const override;
356 void resolveUnnamedParameters(const MemberDef *md) override;
357 void addQualifiers(const StringVector &qualifiers) override;
358 StringVector getQualifiers() const override;
360 void setModuleDef(ModuleDef *mod) override;
361 int redefineCount() const override;
362 void setRedefineCount(int) override;
363 void setClassDefOfAnonymousType(const ClassDef *cd) override;
364 void setIncludeFile(FileDef *fd,const DString &incName,bool local,bool force) override;
365
366 private:
370 void _writeGroupInclude(OutputList &ol,bool inGroup) const;
371 void _writeMultiLineInitializer(OutputList &ol,const DString &scopeName) const;
372 void _writeCallGraph(OutputList &ol) const;
373 void _writeCallerGraph(OutputList &ol) const;
374 void _writeReimplements(OutputList &ol) const;
375 bool _isReimplements() const;
376 void _writeReimplementedBy(OutputList &ol) const;
377 size_t _countReimplementedBy() const;
378 void _writeExamples(OutputList &ol) const;
379 void _writeTypeConstraints(OutputList &ol) const;
380 void _writeEnumValues(OutputList &ol,const Definition *container,
381 const DString &cfname,const DString &ciname,
382 const DString &cname) const;
383 void _writeCategoryRelation(OutputList &ol) const;
384 void _writeTagData(const DefType) const;
385 void _writeTemplatePrefix(OutputList &ol, const Definition *def,
386 const ArgumentList &al, bool writeReqClause=true) const;
387 bool _hasVisibleCallGraph() const;
388 bool _hasVisibleCallerGraph() const;
389 bool _isAnonymousBitField() const;
390
391
392 void init(Definition *def,const DString &t,const DString &a,const DString &e,
393 Protection p,Specifier v,bool s,Relationship r,
394 MemberType mt,const ArgumentList &tal,
395 const ArgumentList &al,const DString &meta
396 );
397
398 uint8_t m_isLinkableCached; // 0 = not cached, 1=false, 2=true
399 uint8_t m_isConstructorCached; // 0 = not cached, 1=false, 2=true
400 uint8_t m_isDestructorCached; // 1 = not cached, 1=false, 2=true
401
402 ClassDef *m_classDef = nullptr; // member of or related to
403 FileDef *m_fileDef = nullptr; // member of file definition
404 NamespaceDef *m_nspace = nullptr; // the namespace this member is in.
406
407 const MemberDef *m_enumScope = nullptr; // the enclosing scope, if this is an enum field
408 bool m_livesInsideEnum = false;
409 const MemberDef *m_annEnumType = nullptr; // the anonymous enum that is the type of this member
410 MemberVector m_enumFields; // enumeration fields
413
414 MemberDef *m_redefines = nullptr; // the members that this member redefines
415 MemberVector m_redefinedBy; // the list of members that redefine this one
416
417 MemberDef *m_memDef = nullptr; // member definition for this declaration
418 MemberDef *m_memDec = nullptr; // member declaration for this definition
419 ClassDef *m_relatedAlso = nullptr; // points to class marked by relatedAlso
420 //
421 std::unique_ptr<IncludeInfo> m_incInfo;
422
423 ExampleList m_examples; // a dictionary of all examples for quick access
424
425 DString m_type; // return actual type
426 DString m_args; // function arguments/variable array specifiers
427 DString m_def; // member definition in code (fully qualified name)
428 DString m_anc; // HTML anchor name
429 Specifier m_virt = Specifier::Normal; // normal/virtual/pure virtual
430 Protection m_prot = Protection::Public; // protection type [Public/Protected/Private]
431 DString m_decl; // member declaration in class
432
433 DString m_bitfields; // struct member bitfields
434 DString m_read; // property read accessor
435 DString m_write; // property write accessor
436 DString m_exception; // exceptions that can be thrown
437 DString m_initializer; // initializer
438 DString m_extraTypeChars; // extra type info found after the argument list
439 DString m_enumBaseType; // base type of the enum (C++11)
440 DString m_requiresClause; // requires clause (C++20)
441 int m_initLines = 0; // number of lines in the initializer
442 bool m_docTransferDone = false;
443
444 TypeSpecifier m_memSpec; // The specifiers present for this member
446 MemberType m_mtype = MemberType::Define; // returns the kind of member
447 int m_maxInitLines = 0; // when the initializer will be displayed
448 int m_userInitLines = 0; // result of explicit \hideinitializer or \showinitializer
449
450 ArgumentList m_defArgList; // argument list of this member definition
451 ArgumentList m_declArgList; // argument list of this member declaration
452
453 ArgumentList m_tArgList; // template argument list of function template
454 ArgumentList m_typeConstraints; // type constraints for template parameters
455 const MemberDef *m_templateMaster = nullptr;
456 std::optional<ArgumentList> m_formalTemplateArguments;
457 ArgumentLists m_defTmpArgLists; // lists of template argument lists
458 // (for template functions in nested template classes)
459
460 DString m_metaData; // Slice metadata.
461
462 const ClassDef *m_anonymousType = nullptr; // if the member has an anonymous compound
463 // as its type then this is computed by
464 // getClassDefOfAnonymousType() and
465 // cached here.
466 std::map<const Definition *,const MemberList *> m_sectionMap;
467
468 const MemberDef *m_groupAlias = nullptr; // Member containing the definition
469 int m_grpId = 0; // group id
470 MemberGroup *m_memberGroup = nullptr; // group's member definition
471 GroupDef *m_group = nullptr; // group in which this member is in
473 DString m_groupFileName; // file where this grouping was defined
474 int m_groupStartLine = 0; // line " " " " "
476
481
482 // documentation inheritance
483 const MemberDef *m_docProvider = nullptr;
484
485 // to store the output file base from tag files
488
489 // to store extra qualifiers
491
492 // objective-c
493 bool m_implOnly = false; // function found in implementation but not
494 // in the interface
495 mutable bool m_hasDocumentedParams = false; // guard to show only the first warning, acts as cache
496 mutable bool m_hasDocumentedReturnType = false; // guard to show only the first warning, acts as cache
497 bool m_isDMember = false;
498 Relationship m_related = Relationship::Member; // relationship of this to the class
499 bool m_stat = false; // is it a static function?
500 bool m_proto = false; // is it a prototype?
501 bool m_docEnumValues = false; // is an enum with documented enum values.
502
503 mutable bool m_hasDetailedDescriptionCached = false;
505 // const member.
506 bool m_hasCallGraph = false;
507 bool m_hasCallerGraph = false;
510 bool m_hasInlineSource = false;
511 bool m_hasEnumValues = false;
512 bool m_explExt = false; // member was explicitly declared external
513 bool m_tspec = false; // member is a template specialization
514 bool m_groupHasDocs = false; // true if the entry that caused the grouping was documented
515 bool m_docsForDefinition = false; // true => documentation block is put before
516 // definition.
517 // false => block is put before declaration.
521 int m_declLine = -1;
522 size_t m_declColumn = 1;
525};
526
527std::unique_ptr<MemberDef> createMemberDef(const DString &defFileName,int defLine,size_t defColumn,
528 const DString &type,const DString &name,const DString &args,
529 const DString &excp,Protection prot,Specifier virt,bool stat,
530 Relationship related,MemberType t,const ArgumentList &tal,
531 const ArgumentList &al,const DString &metaData)
532{
533 return std::make_unique<MemberDefImpl>(defFileName,defLine,defColumn,type,name,args,excp,prot,virt,
534 stat,related,t,tal,al,metaData);
535}
536
537//-----------------------------------------------------------------------------
538
539class MemberDefAliasImpl final : public DefinitionAliasMixin<MemberDef>
540{
541 public:
542 MemberDefAliasImpl(const Definition *newScope,const MemberDef *md)
543 : DefinitionAliasMixin(newScope,md), m_memberGroup(nullptr) { init(); }
544 ~MemberDefAliasImpl() override { deinit(); }
546
547 DefType definitionType() const override { return TypeMember; }
548
549 const MemberDef *getMdAlias() const { return toMemberDef(getAlias()); }
550 MemberDef *getMdAlias() { return toMemberDef(const_cast<Definition*>(getAlias())); }
551 MemberDef *resolveAlias() override { return const_cast<MemberDef*>(getMdAlias()); }
552 const MemberDef *resolveAlias() const override { return getMdAlias(); }
553
554 std::unique_ptr<MemberDef> deepCopy() const override {
556 }
557 void moveTo(Definition *) override {}
558
559 const DString &name() const override
560 { return getMdAlias()->name(); }
562 { return getMdAlias()->codeSymbolType(); }
563 DString getOutputFileBase() const override
564 { return getMdAlias()->getOutputFileBase(); }
565 DString getReference() const override
566 { return getMdAlias()->getReference(); }
567 DString anchor() const override
568 { return getMdAlias()->anchor(); }
569 DString declaration() const override
570 { return getMdAlias()->declaration(); }
571 DString definition() const override
572 { return getMdAlias()->definition(); }
573 DString typeString() const override
574 { return getMdAlias()->typeString(); }
575 DString argsString() const override
576 { return getMdAlias()->argsString(); }
577 DString excpString() const override
578 { return getMdAlias()->excpString(); }
579 DString bitfieldString() const override
580 { return getMdAlias()->bitfieldString(); }
581 DString extraTypeChars() const override
582 { return getMdAlias()->extraTypeChars(); }
583 const DString &initializer() const override
584 { return getMdAlias()->initializer(); }
585 int initializerLines() const override
586 { return getMdAlias()->initializerLines(); }
590 { return getMdAlias()->getVhdlSpecifiers(); }
591 const MemberList *getSectionList(const Definition *container) const override
592 { return getMdAlias()->getSectionList(container); }
593 DString displayDefinition() const override
594 { return getMdAlias()->displayDefinition(); }
595
596 const ClassDef *getClassDef() const override
597 { return getMdAlias()->getClassDef(); }
599 { return getMdAlias()->getClassDef(); }
600
601 const FileDef *getFileDef() const override
602 { return getMdAlias()->getFileDef(); }
603 FileDef *getFileDef() override
604 { return getMdAlias()->getFileDef(); }
605
606 const ModuleDef *getModuleDef() const override
607 { return getMdAlias()->getModuleDef(); }
608
609 const NamespaceDef* getNamespaceDef() const override
610 { return getMdAlias()->getNamespaceDef(); }
612 { return getMdAlias()->getNamespaceDef(); }
613
614 DString getReadAccessor() const override
615 { return getMdAlias()->getReadAccessor(); }
616 DString getWriteAccessor() const override
617 { return getMdAlias()->getWriteAccessor(); }
618 const GroupDef *getGroupDef() const override
619 { return getMdAlias()->getGroupDef(); }
621 { return getMdAlias()->getGroupDef(); }
623 { return getMdAlias()->getGroupPri(); }
624 DString getGroupFileName() const override
625 { return getMdAlias()->getGroupFileName(); }
626 int getGroupStartLine() const override
627 { return getMdAlias()->getGroupStartLine(); }
628 bool getGroupHasDocs() const override
629 { return getMdAlias()->getGroupHasDocs(); }
630 DString qualifiedName() const override
631 { return getMdAlias()->qualifiedName(); }
632 DString objCMethodName(bool localLink,bool showStatic) const override
633 { return getMdAlias()->objCMethodName(localLink,showStatic); }
634 Protection protection() const override
635 { return getMdAlias()->protection(); }
636 Specifier virtualness(int /* count */) const override
637 { return getMdAlias()->virtualness(); }
638 MemberType memberType() const override
639 { return getMdAlias()->memberType(); }
640 DString memberTypeName() const override
641 { return getMdAlias()->memberTypeName(); }
642 bool isSignal() const override
643 { return getMdAlias()->isSignal(); }
644 bool isSlot() const override
645 { return getMdAlias()->isSlot(); }
646 bool isVariable() const override
647 { return getMdAlias()->isVariable(); }
648 bool isEnumerate() const override
649 { return getMdAlias()->isEnumerate(); }
650 bool isEnumValue() const override
651 { return getMdAlias()->isEnumValue(); }
652 bool isTypedef() const override
653 { return getMdAlias()->isTypedef(); }
654 bool isSequence() const override
655 { return getMdAlias()->isSequence(); }
656 bool isDictionary() const override
657 { return getMdAlias()->isDictionary(); }
658 bool isFunction() const override
659 { return getMdAlias()->isFunction(); }
660 bool isFunctionPtr() const override
661 { return getMdAlias()->isFunctionPtr(); }
662 bool isDefine() const override
663 { return getMdAlias()->isDefine(); }
664 bool isFriend() const override
665 { return getMdAlias()->isFriend(); }
666 bool isDCOP() const override
667 { return getMdAlias()->isDCOP(); }
668 bool isProperty() const override
669 { return getMdAlias()->isProperty(); }
670 bool isEvent() const override
671 { return getMdAlias()->isEvent(); }
672 bool isRelated() const override
673 { return getMdAlias()->isRelated(); }
674 bool isForeign() const override
675 { return getMdAlias()->isForeign(); }
676 bool isStatic() const override
677 { return getMdAlias()->isStatic(); }
678 bool isInline() const override
679 { return getMdAlias()->isInline(); }
680 bool isExplicit() const override
681 { return getMdAlias()->isExplicit(); }
682 bool isMutable() const override
683 { return getMdAlias()->isMutable(); }
684 bool isThreadLocal() const override
685 { return getMdAlias()->isThreadLocal(); }
686 bool isGettable() const override
687 { return getMdAlias()->isGettable(); }
688 bool isPrivateGettable() const override
689 { return getMdAlias()->isPrivateGettable(); }
690 bool isProtectedGettable() const override
691 { return getMdAlias()->isProtectedGettable(); }
692 bool isSettable() const override
693 { return getMdAlias()->isSettable(); }
694 bool isPrivateSettable() const override
695 { return getMdAlias()->isPrivateSettable(); }
696 bool isProtectedSettable() const override
697 { return getMdAlias()->isProtectedSettable(); }
698 bool isReadable() const override
699 { return getMdAlias()->isReadable(); }
700 bool isWritable() const override
701 { return getMdAlias()->isWritable(); }
702 bool isAddable() const override
703 { return getMdAlias()->isAddable(); }
704 bool isRemovable() const override
705 { return getMdAlias()->isRemovable(); }
706 bool isRaisable() const override
707 { return getMdAlias()->isRaisable(); }
708 bool isFinal() const override
709 { return getMdAlias()->isFinal(); }
710 bool isAbstract() const override
711 { return getMdAlias()->isAbstract(); }
712 bool isOverride() const override
713 { return getMdAlias()->isOverride(); }
714 bool isInitonly() const override
715 { return getMdAlias()->isInitonly(); }
716 bool isOptional() const override
717 { return getMdAlias()->isOptional(); }
718 bool isRequired() const override
719 { return getMdAlias()->isRequired(); }
720 bool isNonAtomic() const override
721 { return getMdAlias()->isNonAtomic(); }
722 bool isCopy() const override
723 { return getMdAlias()->isCopy(); }
724 bool isAssign() const override
725 { return getMdAlias()->isAssign(); }
726 bool isRetain() const override
727 { return getMdAlias()->isRetain(); }
728 bool isWeak() const override
729 { return getMdAlias()->isWeak(); }
730 bool isStrong() const override
731 { return getMdAlias()->isStrong(); }
732 bool isEnumStruct() const override
733 { return getMdAlias()->isEnumStruct(); }
734 bool isUnretained() const override
735 { return getMdAlias()->isUnretained(); }
736 bool isNew() const override
737 { return getMdAlias()->isNew(); }
738 bool isSealed() const override
739 { return getMdAlias()->isSealed(); }
740 bool isImplementation() const override
741 { return getMdAlias()->isImplementation(); }
742 bool isExternal() const override
743 { return getMdAlias()->isExternal(); }
744 bool isTypeAlias() const override
745 { return getMdAlias()->isTypeAlias(); }
746 bool isDefault() const override
747 { return getMdAlias()->isDefault(); }
748 bool isDelete() const override
749 { return getMdAlias()->isDelete(); }
750 bool isNoExcept() const override
751 { return getMdAlias()->isNoExcept(); }
752 bool isAttribute() const override
753 { return getMdAlias()->isAttribute(); }
754 bool isUNOProperty() const override
755 { return getMdAlias()->isUNOProperty(); }
756 bool isReadonly() const override
757 { return getMdAlias()->isReadable(); }
758 bool isBound() const override
759 { return getMdAlias()->isBound(); }
760 bool isConstrained() const override
761 { return getMdAlias()->isConstrained(); }
762 bool isTransient() const override
763 { return getMdAlias()->isTransient(); }
764 bool isMaybeVoid() const override
765 { return getMdAlias()->isMaybeVoid(); }
766 bool isMaybeDefault() const override
767 { return getMdAlias()->isMaybeDefault(); }
768 bool isMaybeAmbiguous() const override
769 { return getMdAlias()->isMaybeAmbiguous(); }
770 bool isPublished() const override
771 { return getMdAlias()->isPublished(); }
772 bool isTemplateSpecialization() const override
773 { return getMdAlias()->isTemplateSpecialization(); }
774 bool isObjCMethod() const override
775 { return getMdAlias()->isObjCMethod(); }
776 bool isObjCProperty() const override
777 { return getMdAlias()->isObjCProperty(); }
778 bool isCSharpProperty() const override
779 { return getMdAlias()->isCSharpProperty(); }
780 bool isConstructor() const override
781 { return getMdAlias()->isConstructor(); }
782 bool isDestructor() const override
783 { return getMdAlias()->isDestructor(); }
784 bool hasOneLineInitializer() const override
785 { return getMdAlias()->hasOneLineInitializer(); }
786 bool hasMultiLineInitializer() const override
787 { return getMdAlias()->hasMultiLineInitializer(); }
788 bool isCallable() const override
789 { return getMdAlias()->isCallable(); }
790 bool isStrongEnumValue() const override
791 { return getMdAlias()->isStrongEnumValue(); }
792 bool livesInsideEnum() const override
793 { return getMdAlias()->livesInsideEnum(); }
794 bool isSliceLocal() const override
795 { return getMdAlias()->isSliceLocal(); }
796 bool isNoDiscard() const override
797 { return getMdAlias()->isNoDiscard(); }
798 bool isConstExpr() const override
799 { return getMdAlias()->isConstExpr(); }
800 bool isConstEval() const override
801 { return getMdAlias()->isConstEval(); }
802 bool isConstInit() const override
803 { return getMdAlias()->isConstInit(); }
804 int numberOfFlowKeyWords() const override
805 { return getMdAlias()->numberOfFlowKeyWords(); }
806 bool isFriendToHide() const override
807 { return getMdAlias()->isFriendToHide(); }
808 bool isNotFriend() const override
809 { return getMdAlias()->isNotFriend(); }
810 bool isFunctionOrSignalSlot() const override
811 { return getMdAlias()->isFunctionOrSignalSlot(); }
812 bool isRelatedOrFriend() const override
813 { return getMdAlias()->isRelatedOrFriend(); }
814 bool isLinkableInProject() const override
815 { return getMdAlias()->isLinkableInProject(); }
816 bool isLinkable() const override
817 { return getMdAlias()->isLinkable(); }
818 bool hasDocumentation() const override
819 { return getMdAlias()->hasDocumentation(); }
820 bool hasUserDocumentation() const override
821 { return getMdAlias()->hasUserDocumentation(); }
822 bool isDeleted() const override
823 { return getMdAlias()->isDeleted(); }
824 bool isBriefSectionVisible() const override
825 { return getMdAlias()->isBriefSectionVisible(); }
826 bool isDetailedSectionVisible(MemberListContainer container) const override
827 { return getMdAlias()->isDetailedSectionVisible(container); }
828 bool hasDetailedDescription() const override
829 { return getMdAlias()->hasDetailedDescription(); }
830 bool isFriendClass() const override
831 { return getMdAlias()->isFriendClass(); }
832 bool isDocumentedFriendClass() const override
833 { return getMdAlias()->isDocumentedFriendClass(); }
834 const MemberDef *reimplements() const override
835 { return getMdAlias()->reimplements(); }
836 const MemberVector &reimplementedBy() const override
837 { return getMdAlias()->reimplementedBy(); }
838 bool isReimplementedBy(const ClassDef *cd) const override
839 { return getMdAlias()->isReimplementedBy(cd); }
840 ClassDef *relatedAlso() const override
841 { return getMdAlias()->relatedAlso(); }
842 bool hasDocumentedEnumValues() const override
843 { return getMdAlias()->hasDocumentedEnumValues(); }
844 const MemberDef *getAnonymousEnumType() const override
845 { return getMdAlias()->getAnonymousEnumType(); }
848 const MemberDef *anonymousMemberForDetails() const override
850 bool isDocsForDefinition() const override
851 { return getMdAlias()->isDocsForDefinition(); }
852 const MemberDef *getEnumScope() const override
853 { return getMdAlias()->getEnumScope(); }
854 const MemberVector &enumFieldList() const override
855 { return getMdAlias()->enumFieldList(); }
856 DString enumBaseType() const override
857 { return getMdAlias()->enumBaseType(); }
858 bool hasExamples() const override
859 { return getMdAlias()->hasExamples(); }
860 const ExampleList &getExamples() const override
861 { return getMdAlias()->getExamples(); }
862 bool isPrototype() const override
863 { return getMdAlias()->isPrototype(); }
864 const ArgumentList &argumentList() const override
865 { return getMdAlias()->argumentList(); }
866 const ArgumentList &declArgumentList() const override
867 { return getMdAlias()->declArgumentList(); }
868 const ArgumentList &templateArguments() const override
869 { return getMdAlias()->templateArguments(); }
872 std::optional<ArgumentList> formalTemplateArguments() const override
873 { return getMdAlias()->formalTemplateArguments(); }
874 int getMemberGroupId() const override
875 { return getMdAlias()->getMemberGroupId(); }
876 MemberGroup *getMemberGroup() const override
877 { return m_memberGroup; }
878 bool hasCallGraph() const override
879 { return getMdAlias()->hasCallGraph(); }
880 bool hasCallerGraph() const override
881 { return getMdAlias()->hasCallerGraph(); }
882 bool hasReferencesRelation() const override
883 { return getMdAlias()->hasReferencesRelation(); }
884 bool hasReferencedByRelation() const override
885 { return getMdAlias()->hasReferencedByRelation(); }
886 bool hasInlineSource() const override
887 { return getMdAlias()->hasInlineSource(); }
888 bool isDocTransferDone() const override
889 { return getMdAlias()->isDocTransferDone(); }
890 DString sourceRefName() const override
891 { return getMdAlias()->sourceRefName(); }
892 bool hasEnumValues() const override
893 { return getMdAlias()->hasEnumValues(); }
895 { return getMdAlias()->getQualifiers(); }
896 const MemberDef *templateMaster() const override
897 { return getMdAlias()->templateMaster(); }
898 DString getScopeString() const override
899 { return getMdAlias()->getScopeString(); }
900 const ClassDef *getClassDefOfAnonymousType() const override
902 bool isTypedefValCached() const override
903 { return getMdAlias()->isTypedefValCached(); }
904 const ClassDef *getCachedTypedefVal() const override
905 { return getMdAlias()->getCachedTypedefVal(); }
910 MemberDef *memberDefinition() const override
911 { return getMdAlias()->memberDefinition(); }
912 MemberDef *memberDeclaration() const override
913 { return getMdAlias()->memberDeclaration(); }
914 const MemberDef *inheritsDocsFrom() const override
915 { return getMdAlias()->inheritsDocsFrom(); }
916 const MemberDef *getGroupAlias() const override
917 { return getMdAlias()->getGroupAlias(); }
918 ClassDef *category() const override
919 { return getMdAlias()->category(); }
920 const MemberDef *categoryRelation() const override
921 { return getMdAlias()->categoryRelation(); }
922 DString displayName(bool b=true) const override
923 { return getMdAlias()->displayName(b); }
924 DString getDeclType() const override
925 { return getMdAlias()->getDeclType(); }
926 StringVector getLabels(const Definition *container) const override
927 { return getMdAlias()->getLabels(container); }
928 const ArgumentList &typeConstraints() const override
929 { return getMdAlias()->typeConstraints(); }
930 DString documentation() const override
931 { return getMdAlias()->documentation(); }
932 DString briefDescription(bool /* abbr=false */) const override
933 { return getMdAlias()->briefDescription(); }
934 DString fieldType() const override
935 { return getMdAlias()->fieldType(); }
936 bool isReference() const override
937 { return getMdAlias()->isReference(); }
938 DString getDeclFileName() const override
939 { return getMdAlias()->getDeclFileName(); }
940 int getDeclLine() const override
941 { return getMdAlias()->getDeclLine(); }
942 size_t getDeclColumn() const override
943 { return getMdAlias()->getDeclColumn(); }
944 DString requiresClause() const override
945 { return getMdAlias()->requiresClause(); }
946 bool visibleInIndex() const override
947 { return getMdAlias()->visibleInIndex(); }
948 int redefineCount() const override
949 { return getMdAlias()->redefineCount(); }
950
951 void warnIfUndocumented() const override {}
952 void warnIfUndocumentedParams() const override {}
953 void detectUndocumentedParams(bool /* hasParamCommand */,bool /* hasReturnCommand */) const override {}
954 void setMemberGroup(MemberGroup *grp) override { m_memberGroup = grp; }
955 std::unique_ptr<MemberDef> createTemplateInstanceMember(const ArgumentList &formalArgs,
956 const std::unique_ptr<ArgumentList> &actualArgs) const override
957 { return getMdAlias()->createTemplateInstanceMember(formalArgs,actualArgs); }
958
960 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
961 bool inGroup, int indentLevel, const ClassDef *inheritFrom=nullptr,const DString &inheritId=DString(),
962 const DString &declAnchor=DString()) const override
963 {
964 // The alias is shown in another scope than the original member. Give its declaration an anchor of
965 // its own, so it does not clash with the one of the original (links still use the original anchor).
966 DString aliasAnchor = declAnchor;
967 if (aliasAnchor.empty() && getScope())
968 {
969 aliasAnchor = "a"+md5str((getScope()->getOutputFileBase()+"_"+getMdAlias()->anchor()).view());
970 }
971 getMdAlias()->writeDeclaration(ol,cd,nd,fd,gd,mod,inGroup,indentLevel,inheritFrom,inheritId,aliasAnchor);
972 }
974 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const override
975 {
976 getMdAlias()->writeEnumDeclaration(typeDecl,cd,nd,fd,gd,mod);
977 }
979 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
980 bool onlyText=false) const override
981 {
982 getMdAlias()->writeLink(ol,cd,nd,fd,gd,mod,onlyText);
983 }
984 private:
985 MemberGroup *m_memberGroup; // group's member definition
986};
987
988
989std::unique_ptr<MemberDef> createMemberDefAlias(const Definition *newScope,const MemberDef *aliasMd)
990{
991 auto amd = std::make_unique<MemberDefAliasImpl>(newScope,aliasMd);
992 //printf("amd: name=%s displayName=%s\n",qPrint(amd->name()),qPrint(amd->displayName()));
993 return amd;
994}
995
996//-----------------------------------------------------------------------------
997
998static void writePageRef(OutputList &ol,const DString &cn,const DString &mn)
999{
1000 ol.pushGeneratorState();
1001
1005 if (Config_getBool(PDF_HYPERLINKS)) ol.disable(OutputType::Latex);
1006 if (Config_getBool(RTF_HYPERLINKS)) ol.disable(OutputType::RTF);
1007 ol.startPageRef();
1009 ol.endPageRef(cn,mn);
1010
1011 ol.popGeneratorState();
1012}
1013
1014
1015//-----------------------------------------------------------------------------
1016
1017static DString addTemplateNames(const DString &s,const DString &n,const DString &t)
1018{
1019 DString result;
1020 DString clRealName=n;
1021 size_t p=0,i=0;
1022 if ((i=clRealName.find('<'))!=DString::npos)
1023 {
1024 clRealName=clRealName.left(i); // strip template specialization
1025 }
1026 if ((i=clRealName.rfind("::"))!=DString::npos)
1027 {
1028 clRealName=clRealName.mid(i+2);
1029 }
1030 while ((i=s.find(clRealName,p))!=DString::npos)
1031 {
1032 result+=s.mid(p,i-p);
1033 size_t j=clRealName.length()+i;
1034 if (s.length()==j || (s.at(j)!='<' && !isId(s.at(j))))
1035 { // add template names
1036 //printf("Adding %s+%s\n",qPrint(clRealName),qPrint(t));
1037 result+=clRealName+t;
1038 }
1039 else
1040 { // template names already present
1041 //printf("Adding %s\n",qPrint(clRealName));
1042 result+=clRealName;
1043 }
1044 p=i+clRealName.length();
1045 }
1046 result+=s.mid(p);
1047 //printf("addTemplateNames(%s,%s,%s)=%s\n",qPrint(s),qPrint(n),qPrint(t),qPrint(result));
1048 return result;
1049}
1050
1051// ol.startMemberDocName has already been done before this is called.
1052// when this function returns true, ol.endParameterList will be called.
1053//
1054// typical sequence:
1055// ol.startMemberDoc
1056// ol.startMemberDocName
1057// --- enter writeDefArgumentList
1058// ol.endMemberDocName
1059// ol.startParameterList
1060// ...
1061// ol.startParameterType(first=true)
1062// ol.endParameterType
1063// ol.startParameterName
1064// ol.endParameterName
1065// ol.startParameterExtra
1066// ol.startParameterDefVal [optional]
1067// ol.endParameterDefVal [optional]
1068// ol.endParameterExtra(last==false)
1069// ...
1070// ol.startParameterType(first=false)
1071// ol.endParameterType
1072// ol.startParameterName
1073// ol.endParameterName
1074// ol.startParameterExtra
1075// ol.endParameterExtra(last==true)
1076// ...
1077// --- leave writeDefArgumentList with return value true
1078// ol.endParameterList
1079// ol.endMemberDoc(hasArgs=true)
1080//
1081// For an empty list the function should return false, the sequence is
1082// ol.startMemberDoc
1083// ol.startMemberDocName
1084// --- enter writeDefArgumentList
1085// --- leave writeDefArgumentList with return value false
1086// ol.endMemberDocName
1087// ol.endMemberDoc(hasArgs=false);
1088//
1089
1090static bool writeDefArgumentList(OutputList &ol,const Definition *scope,const MemberDef *md)
1091{
1092 const ArgumentList &defArgList=(md->isDocsForDefinition()) ?
1093 md->argumentList() : md->declArgumentList();
1094 //printf("writeDefArgumentList '%s' isDocsForDefinition()=%d hasParameters()=%d (%s)\n",
1095 // qPrint(md->name()),md->isDocsForDefinition(),defArgList.hasParameters(),qPrint(argListToString(defArgList)));
1096 if (!defArgList.hasParameters() || md->isProperty() || md->isTypedef())
1097 {
1098 return false; // member has no function like argument list
1099 }
1100
1101 bool isDefine = md->isDefine();
1102 if (!isDefine) ol.docify(" ");
1103
1104 //printf("writeDefArgList(%d)\n",defArgList->count());
1105 ol.endMemberDocName();
1107 //printf("===> name=%s isDefine=%d\n",qPrint(md->name()),md->isDefine());
1108
1109 DString cName;
1110 if (scope)
1111 {
1112 cName=scope->name();
1113 size_t il=cName.find('<');
1114 size_t ir=cName.rfind('>');
1115 if (il!=DString::npos && ir!=DString::npos && ir>il)
1116 {
1117 cName=cName.mid(il,ir-il+1);
1118 //printf("1. cName=%s\n",qPrint(cName));
1119 }
1120 else if (scope->definitionType()==Definition::TypeClass)
1121 {
1122 cName=tempArgListToString((toClassDef(scope))->templateArguments(),
1123 scope->getLanguage());
1124 //printf("2. cName=%s\n",qPrint(cName));
1125 }
1126 else // no template specifier
1127 {
1128 cName.clear();
1129 }
1130 }
1131 //printf("~~~ %s cName=%s\n",qPrint(md->name()),qPrint(cName));
1132
1134
1135 LinkifyTextOptions options;
1136 options.setScope(scope).setFileScope(md->getBodyDef()).setSelf(md);
1137
1138 bool first=true;
1139 bool paramTypeStarted=false;
1140 auto alIt = defArgList.begin();
1141 while (alIt!=defArgList.end())
1142 {
1143 Argument a = *alIt;
1144 if (isDefine || first)
1145 {
1146 ol.startParameterType(first,DString());
1147 paramTypeStarted=true;
1148 if (isDefine)
1149 {
1150 ol.endParameterType();
1151 ol.startParameterName(true);
1152 }
1153 }
1154
1155 if (!a.attrib.empty() && !md->isObjCMethod()) // argument has an IDL attribute
1156 {
1157 ol.docify(a.attrib+" ");
1158 }
1159
1160 DString atype = a.type;
1161 if (sep!="::") { atype=substitute(atype,"::",sep); }
1162
1163 size_t funcPtrPos=DString::npos;
1164 {
1165 if (md->isObjCMethod()) { atype.prepend("("); atype.append(")"); }
1166 if (atype!="...")
1167 {
1168 if (!cName.empty() && scope && scope!=Doxygen::globalScope)
1169 {
1170 atype=addTemplateNames(atype,scope->name(),cName);
1171 }
1172 // 1. split ...*)(... -> '*' + name + ')(...'
1173 // 2. split ...*[some thing])(... -> '*' + name + '[some thing])(...'
1174 size_t starPos = atype.find('*'); // find pointer
1175 if (starPos==DString::npos) starPos = atype.find('&'); // can also be reference
1176 funcPtrPos = atype.find(")(");
1177 if (starPos!=DString::npos && funcPtrPos!=DString::npos && funcPtrPos>starPos)
1178 {
1179 funcPtrPos=starPos+1;
1180 }
1181 else
1182 {
1183 funcPtrPos=DString::npos;
1184 }
1186 funcPtrPos==DString::npos ? atype : atype.left(funcPtrPos),
1187 options);
1188 }
1189 }
1190
1191 if (!isDefine)
1192 {
1193 if (paramTypeStarted)
1194 {
1195 ol.endParameterType();
1196 paramTypeStarted=false;
1197 }
1198 ol.startParameterName(defArgList.size()<2);
1199 }
1200 else
1201 {
1202 ol.endParameterName();
1203 }
1204
1205 if (atype=="...")
1206 {
1207 ol.docify(atype);
1208 }
1209 else if (!a.name.empty()) // argument has a name
1210 {
1211 ol.docify(a.name);
1212 }
1213 if (!isDefine)
1214 {
1215 if (funcPtrPos!=DString::npos)
1216 {
1218 }
1219 ol.endParameterName();
1220 }
1222 if (funcPtrPos!=DString::npos)
1223 {
1224 linkifyText(TextGeneratorOLImpl(ol),atype.mid(funcPtrPos),options);
1225 }
1226 if (!a.array.empty())
1227 {
1228 ol.docify(a.array);
1229 }
1230 if (!a.defval.empty()) // write the default value
1231 {
1232 DString n=a.defval;
1233 if (scope && scope!=Doxygen::globalScope && !cName.empty())
1234 {
1235 n=addTemplateNames(n,scope->name(),cName);
1236 }
1237 ol.startParameterDefVal(" = ");
1238 linkifyText(TextGeneratorOLImpl(ol),n,LinkifyTextOptions(options).setKeepSpaces(true));
1239 ol.endParameterDefVal();
1240 }
1241 ++alIt;
1242 if (alIt!=defArgList.end())
1243 {
1244 a = *alIt;
1245 if (!md->isObjCMethod()) ol.docify(", "); // there are more arguments
1246 if (!isDefine)
1247 {
1248 DString key;
1249 if (md->isObjCMethod() && a.attrib.length()>=2)
1250 {
1251 //printf("Found parameter keyword %s\n",a.qPrint(attrib));
1252 // strip [ and ]
1253 key=a.attrib.mid(1,a.attrib.length()-2);
1254 if (key!=",") key+=":"; // for normal keywords add colon
1255 }
1256 ol.endParameterExtra(false,false,!md->isObjCMethod());
1257 ol.startParameterType(false,key);
1258 paramTypeStarted=true;
1259 }
1260 else // isDefine
1261 {
1262 ol.endParameterExtra(false,false,true);
1263 }
1264 }
1265 first=false;
1266 }
1267 if (first)
1268 {
1269 ol.startParameterName(defArgList.size()<2);
1270 ol.endParameterName();
1272 }
1273 ol.endParameterExtra(true,defArgList.size()<2,!md->isObjCMethod());
1274 if (!md->extraTypeChars().empty())
1275 {
1276 ol.docify(md->extraTypeChars());
1277 }
1278 if (defArgList.constSpecifier())
1279 {
1280 ol.docify(" const");
1281 }
1282 if (defArgList.volatileSpecifier())
1283 {
1284 ol.docify(" volatile");
1285 }
1286 if (defArgList.refQualifier()==RefQualifierType::LValue)
1287 {
1288 ol.docify(" &");
1289 }
1290 else if (defArgList.refQualifier()==RefQualifierType::RValue)
1291 {
1292 ol.docify(" &&");
1293 }
1294 if (!defArgList.trailingReturnType().empty())
1295 {
1296 linkifyText(TextGeneratorOLImpl(ol), defArgList.trailingReturnType(), options);
1297 }
1298 return true;
1299}
1300
1302 OutputList &ol, const ClassDef *cd, const MemberDef *md, DString const& exception)
1303{
1304 // this is ordinary exception spec - there must be a '('
1305 //printf("exception='%s'\n",qPrint(exception));
1306 size_t index = exception.find('(');
1307 LinkifyTextOptions options;
1308 options.setScope(cd).setFileScope(md->getBodyDef()).setSelf(md);
1309 if (index!=DString::npos)
1310 {
1311 ol.exceptionEntry(exception.left(index),false);
1312 ++index; // paren in second column so skip it here
1313 for (size_t comma = exception.find(',', index); comma!=DString::npos; )
1314 {
1315 ++comma; // include comma
1316 linkifyText(TextGeneratorOLImpl(ol),exception.mid(index,comma-index),options);
1317 ol.exceptionEntry(DString(),false);
1318 index=comma;
1319 comma = exception.find(',', index);
1320 }
1321 if (size_t close = exception.find(')', index); close!=DString::npos)
1322 {
1323 DString type=removeRedundantWhiteSpace(exception.mid(index,close-index));
1324 linkifyText(TextGeneratorOLImpl(ol),type,options);
1325 ol.exceptionEntry(DString(),true);
1326 }
1327 else
1328 {
1329 warn(md->getDefFileName(),md->getDefLine(),
1330 "missing ) in exception list on member {}",md->name());
1331 }
1332 }
1333 else // Java Exception
1334 {
1335 ol.docify(" ");
1336 linkifyText(TextGeneratorOLImpl(ol),exception,options);
1337 }
1338}
1339
1340static void writeExceptionList(OutputList &ol, const ClassDef *cd, const MemberDef *md)
1341{
1342 DString exception = md->excpString().stripWhiteSpace();
1343 if (exception.at(0)=='{')
1344 {
1345 // this is an UNO IDL attribute - need special handling
1346 size_t index = exception.find(';');
1347 size_t oldIndex = 1;
1348 while (index!=DString::npos) // there should be no more than 2 (set / get)
1349 {
1350 // omit '{' and ';' -> "set raises (...)"
1351 writeExceptionListImpl(ol,cd,md,exception.mid(oldIndex,index-oldIndex));
1352 oldIndex = index+1;
1353 index = exception.find(';',oldIndex);
1354 }
1355 // the rest is now just '}' - omit that
1356 }
1357 else
1358 {
1359 writeExceptionListImpl(ol,cd,md,exception);
1360 }
1361}
1362
1363//-----------------------------------------------------------------------------
1364//-----------------------------------------------------------------------------
1365//-----------------------------------------------------------------------------
1366
1368 const DString &t,const DString &a,const DString &e,
1369 Protection p,Specifier v,bool s,Relationship r,
1370 MemberType mt,const ArgumentList &tal,
1371 const ArgumentList &al,const DString &meta
1372 )
1373{
1374 m_classDef=nullptr;
1375 m_fileDef=nullptr;
1376 m_moduleDef=nullptr;
1377 m_redefines=nullptr;
1378 m_relatedAlso=nullptr;
1379 m_nspace=nullptr;
1380 m_memDef=nullptr;
1381 m_memDec=nullptr;
1382 m_group=nullptr;
1383 m_grpId=-1;
1384 m_enumScope=nullptr;
1385 m_livesInsideEnum=false;
1386 m_hasCallGraph = Config_getBool(CALL_GRAPH);
1387 m_hasCallerGraph = Config_getBool(CALLER_GRAPH);
1388 m_hasReferencedByRelation = Config_getBool(REFERENCED_BY_RELATION);
1389 m_hasReferencesRelation = Config_getBool(REFERENCES_RELATION);
1390 m_hasEnumValues = Config_getBool(SHOW_ENUM_VALUES);
1391 m_hasInlineSource = Config_getBool(INLINE_SOURCES);
1392 m_initLines=0;
1393 m_type=t;
1394 if (mt==MemberType::Typedef) m_type.stripPrefix("typedef ");
1395 // type.stripPrefix("struct ");
1396 // type.stripPrefix("record ");
1397 // type.stripPrefix("class " );
1398 // type.stripPrefix("union " );
1400 m_args=a;
1402 if (m_type.empty()) m_decl=d->name()+m_args; else m_decl=m_type+" "+d->name()+m_args;
1403
1404 m_memberGroup=nullptr;
1405 m_virt=v;
1406 m_prot=p;
1407 m_related=r;
1408 m_stat=s;
1409 m_mtype=mt;
1410 m_exception=e;
1411 m_proto=false;
1414 m_annEnumType=nullptr;
1415 m_annMemberForDecl=nullptr;
1416 m_annMemberForDetails=nullptr;
1417 m_groupAlias=nullptr;
1418 m_explExt=false;
1419 m_tspec=false;
1420 m_anonymousType=nullptr;
1421 m_maxInitLines=Config_getInt(MAX_INITIALIZER_LINES);
1422 m_userInitLines=-1;
1423 m_docEnumValues=false;
1424 // copy function template arguments (if any)
1425 m_tArgList = tal;
1426 //printf("new member al=%p\n",al);
1427 // copy function definition arguments (if any)
1428 m_defArgList = al;
1429 // convert function declaration arguments (if any)
1430 if (!m_args.empty())
1431 {
1433 //printf("setDeclArgList %s to %s const=%d\n",qPrint(args),
1434 // qPrint(argListToString(declArgList)),declArgList->constSpecifier);
1435 }
1436 m_metaData = meta;
1437 m_templateMaster = nullptr;
1438 m_docsForDefinition = true;
1439 m_isTypedefValCached = false;
1440 m_cachedTypedefValue = nullptr;
1441 m_implOnly=false;
1442 m_groupMember = nullptr;
1443 m_hasDocumentedParams = false;
1445 m_docProvider = nullptr;
1447}
1448
1449
1450//-----------------------------------------------------------------------------
1451//-----------------------------------------------------------------------------
1452//-----------------------------------------------------------------------------
1453
1454/*! Creates a new member definition.
1455 *
1456 * \param df File containing the definition of this member.
1457 * \param dl Line at which the member definition was found.
1458 * \param dc Column at which the member definition was found.
1459 * \param t A string representing the type of the member.
1460 * \param na A string representing the name of the member.
1461 * \param a A string representing the arguments of the member.
1462 * \param e A string representing the throw clause of the members.
1463 * \param p The protection context of the member, possible values are:
1464 * \c Public, \c Protected, \c Private.
1465 * \param v The degree of 'virtualness' of the member, possible values are:
1466 * \c Normal, \c Virtual, \c Pure.
1467 * \param s A boolean that is true iff the member is static.
1468 * \param r The relationship between the class and the member.
1469 * \param mt The kind of member. See #MemberType for a list of
1470 * all types.
1471 * \param tal The template arguments of this member.
1472 * \param al The arguments of this member. This is a structured form of
1473 * the string past as argument \a a.
1474 * \param meta Slice metadata.
1475 */
1476
1477MemberDefImpl::MemberDefImpl(const DString &df,int dl,size_t dc,
1478 const DString &t,const DString &na,const DString &a,const DString &e,
1480 const ArgumentList &tal,const ArgumentList &al,const DString &meta
1482{
1483 //printf("MemberDefImpl::MemberDef(%s)\n",qPrint(na));
1484 init(this,t,a,e,p,v,s,r,mt,tal,al,meta);
1488}
1489
1490std::unique_ptr<MemberDef> MemberDefImpl::deepCopy() const
1491{
1492 std::unique_ptr<MemberDefImpl> result(new MemberDefImpl(
1495 // first copy base members
1496 result->DefinitionMixin<MemberDefMutable>::operator=(*this);
1497 // then copy other members
1498 result->m_typeConstraints = m_typeConstraints ;
1499 result->m_declArgList = m_declArgList ;
1500 result->m_classDef = m_classDef ;
1501 result->m_fileDef = m_fileDef ;
1502 result->m_moduleDef = m_moduleDef ;
1503 result->m_nspace = m_nspace ;
1504 result->m_enumScope = m_enumScope ;
1505 result->m_livesInsideEnum = m_livesInsideEnum ;
1506 result->m_annEnumType = m_annEnumType ;
1507 result->m_annMemberForDecl = m_annMemberForDecl ;
1508 result->m_annMemberForDetails = m_annMemberForDetails ;
1509 result->m_enumFields = m_enumFields ;
1510 result->m_redefines = m_redefines ;
1511 result->m_redefinedBy = m_redefinedBy ;
1512 result->m_memDef = m_memDef ;
1513 result->m_memDec = m_memDec ;
1514 result->m_relatedAlso = m_relatedAlso ;
1515 result->m_examples = m_examples ;
1516 result->m_def = m_def ;
1517 result->m_anc = m_anc ;
1518 result->m_decl = m_decl ;
1519 result->m_bitfields = m_bitfields ;
1520 result->m_read = m_read ;
1521 result->m_write = m_write ;
1522 result->m_exception = m_exception ;
1523 result->m_initializer = m_initializer ;
1524 result->m_extraTypeChars = m_extraTypeChars ;
1525 result->m_enumBaseType = m_enumBaseType ;
1526 result->m_requiresClause = m_requiresClause ;
1527 result->m_initLines = m_initLines ;
1528 result->m_memSpec = m_memSpec ;
1529 result->m_vhdlSpec = m_vhdlSpec ;
1530 result->m_maxInitLines = m_maxInitLines ;
1531 result->m_userInitLines = m_userInitLines ;
1532 result->m_defArgList = m_defArgList ;
1533 result->m_declArgList = m_declArgList ;
1534 result->m_tArgList = m_tArgList ;
1535 result->m_typeConstraints = m_typeConstraints ;
1536 result->m_templateMaster = m_templateMaster ;
1537 result->m_formalTemplateArguments = m_formalTemplateArguments ;
1538 result->m_defTmpArgLists = m_defTmpArgLists ;
1539 result->m_anonymousType = m_anonymousType ;
1540 result->m_sectionMap = m_sectionMap ;
1541 result->m_groupAlias = m_groupAlias ;
1542 result->m_grpId = m_grpId ;
1543 result->m_memberGroup = m_memberGroup ;
1544 result->m_group = m_group ;
1545 result->m_grouppri = m_grouppri ;
1546 result->m_groupFileName = m_groupFileName ;
1547 result->m_groupStartLine = m_groupStartLine ;
1548 result->m_groupMember = m_groupMember ;
1549 result->m_isTypedefValCached = m_isTypedefValCached ;
1550 result->m_cachedTypedefValue = m_cachedTypedefValue ;
1551 result->m_cachedTypedefTemplSpec = m_cachedTypedefTemplSpec ;
1552 result->m_cachedResolvedType = m_cachedResolvedType ;
1553 result->m_docProvider = m_docProvider ;
1554 result->m_explicitOutputFileBase = m_explicitOutputFileBase ;
1555 result->m_qualifiers = m_qualifiers ;
1556 result->m_implOnly = m_implOnly ;
1557 result->m_hasDocumentedParams = m_hasDocumentedParams ;
1558 result->m_hasDocumentedReturnType = m_hasDocumentedReturnType ;
1559 result->m_isDMember = m_isDMember ;
1560 result->m_proto = m_proto ;
1561 result->m_docEnumValues = m_docEnumValues ;
1562 result->m_hasDetailedDescriptionCached = m_hasDetailedDescriptionCached ;
1563 result->m_detailedDescriptionCachedValue = m_detailedDescriptionCachedValue ;
1564 result->m_hasCallGraph = m_hasCallGraph ;
1565 result->m_hasCallerGraph = m_hasCallerGraph ;
1566 result->m_hasReferencedByRelation = m_hasReferencedByRelation ;
1567 result->m_hasReferencesRelation = m_hasReferencesRelation ;
1568 result->m_hasEnumValues = m_hasEnumValues ;
1569 result->m_hasInlineSource = m_hasInlineSource ;
1570 result->m_explExt = m_explExt ;
1571 result->m_tspec = m_tspec ;
1572 result->m_groupHasDocs = m_groupHasDocs ;
1573 result->m_docsForDefinition = m_docsForDefinition ;
1574 result->m_category = m_category ;
1575 result->m_categoryRelation = m_categoryRelation ;
1576 result->m_declFileName = m_declFileName ;
1577 result->m_declLine = m_declLine ;
1578 result->m_declColumn = m_declColumn ;
1579 result->m_numberOfFlowKW = m_numberOfFlowKW ;
1580 result->setDefinitionTemplateParameterLists(m_defTmpArgLists);
1581 if (m_incInfo)
1582 {
1583 result->m_incInfo = std::make_unique<IncludeInfo>();
1584 *(result->m_incInfo) = *m_incInfo;
1585 }
1586
1587 result->m_isLinkableCached = 0;
1588 result->m_isConstructorCached = 0;
1589 result->m_isDestructorCached = 0;
1590 return result;
1591}
1592
1594{
1595 setOuterScope(scope);
1597 {
1598 m_classDef = toClassDef(scope);
1599 }
1600 else if (scope->definitionType()==Definition::TypeFile)
1601 {
1602 m_fileDef = toFileDef(scope);
1603 }
1604 else if (scope->definitionType()==Definition::TypeModule)
1605 {
1606 m_moduleDef = toModuleDef(scope);
1607 }
1608 else if (scope->definitionType()==Definition::TypeNamespace)
1609 {
1610 m_nspace = toNamespaceDef(scope);
1611 }
1614}
1615
1616
1621
1623{
1624 if (m_templateMaster)
1625 {
1627 if (mdm)
1628 {
1629 mdm->insertReimplementedBy(md);
1630 }
1631 }
1632 if (!m_redefinedBy.contains(md))
1633 {
1635 }
1636}
1637
1639{
1640 return m_redefines;
1641}
1642
1644{
1645 return m_redefinedBy;
1646}
1647
1649{
1650 if (cd)
1651 {
1652 for (const auto &md : m_redefinedBy)
1653 {
1654 const ClassDef *mcd = md->getClassDef();
1655 if (mcd)
1656 {
1657 if (cd==mcd || cd->isBaseClass(mcd,true))
1658 {
1659 return true;
1660 }
1661 }
1662 }
1663 }
1664 return false;
1665}
1666
1671
1672bool MemberDefImpl::addExample(const DString &anchor,const DString &nameStr, const DString &file)
1673{
1674 //printf("%s::addExample(%s,%s,%s)\n",qPrint(name()),anchor,nameStr,file);
1675 return m_examples.inSort(Example(anchor,nameStr,file));
1676}
1677
1679{
1680 return !m_examples.empty();
1681}
1682
1684{
1685 DString n = name();
1686 DString s = getScopeString();
1687
1688 if (!s.empty())
1689 {
1690 n.prepend(s+"::");
1691 }
1692 else if (isStatic() && getFileDef())
1693 {
1694 n.prepend(getFileDef()->name()+":");
1695 }
1696 if (isCallable())
1697 {
1698 n.append(argsString());
1699 }
1700 return n;
1701}
1702
1704{
1705 bool separateMemberPages = Config_getBool(SEPARATE_MEMBER_PAGES);
1706 bool inlineSimpleClasses = Config_getBool(INLINE_SIMPLE_STRUCTS);
1707 DString baseName;
1708
1709 //printf("Member: %s: templateMaster=%p group=%p classDef=%p nspace=%p fileDef=%p\n",
1710 // qPrint(name()),m_templateMaster,m_group,m_classDef,
1711 // m_nspace,m_fileDef);
1712 const NamespaceDef *nspace = getNamespaceDef();
1713 const FileDef *fileDef = getFileDef();
1714 const ClassDef *classDef = getClassDef();
1715 const ModuleDef *moduleDef = getModuleDef();
1716 const GroupDef *groupDef = getGroupDef();
1718 {
1720 }
1721 else if (templateMaster() && (classDef==nullptr || classDef->isImplicitTemplateInstance()))
1722 {
1724 }
1725 else if (anonymousMemberForDetails())
1726 {
1728 }
1729 else if (groupDef)
1730 {
1731 baseName=groupDef->getOutputFileBase();
1732 }
1733 else if (classDef)
1734 {
1735 baseName=classDef->getOutputFileBase();
1736 if (inlineSimpleClasses && classDef->isSimple())
1737 {
1738 return baseName;
1739 }
1740 }
1741 else if (nspace && (nspace->isLinkable() || nspace->isAnonymous()))
1742 {
1743 baseName=nspace->getOutputFileBase();
1744 }
1745 else if (fileDef)
1746 {
1747 baseName=fileDef->getOutputFileBase();
1748 }
1749 else if (moduleDef)
1750 {
1751 baseName=moduleDef->getOutputFileBase();
1752 }
1753
1754 if (baseName.empty())
1755 {
1757 "Internal inconsistency: member {} does not belong to any container!",name()
1758 );
1759 return "dummy";
1760 }
1761 else if (separateMemberPages && hasDetailedDescription())
1762 {
1763 if (getEnumScope()) // enum value, which is part of enum's documentation
1764 {
1765 baseName+="_"+getEnumScope()->anchor();
1766 }
1767 else
1768 {
1769 baseName+="_"+anchor();
1770 }
1771 }
1772 return baseName;
1773}
1774
1776{
1778 if (!ref.empty())
1779 {
1780 return ref;
1781 }
1782 const NamespaceDef *nspace = getNamespaceDef();
1783 const FileDef *fileDef = getFileDef();
1784 const ClassDef *classDef = getClassDef();
1785 const ModuleDef *moduleDef = getModuleDef();
1786 const GroupDef *groupDef = getGroupDef();
1787 if (templateMaster())
1788 {
1789 return templateMaster()->getReference();
1790 }
1791 else if (groupDef)
1792 {
1793 return groupDef->getReference();
1794 }
1795 else if (classDef)
1796 {
1797 return classDef->getReference();
1798 }
1799 else if (nspace)
1800 {
1801 return nspace->getReference();
1802 }
1803 else if (moduleDef)
1804 {
1805 return moduleDef->getReference();
1806 }
1807 else if (fileDef)
1808 {
1809 return fileDef->getReference();
1810 }
1811 return "";
1812}
1813
1815{
1816 DString result=m_anc;
1817 if (m_groupAlias) return m_groupAlias->anchor();
1820 if (m_enumScope && m_enumScope!=this) // avoid recursion for C#'s public enum E { E, F }
1821 {
1822 result.prepend(m_enumScope->anchor());
1823 }
1824 if (getGroupDef())
1825 {
1826 if (m_groupMember)
1827 {
1828 result=m_groupMember->anchor();
1829 }
1830 else if (getReference().empty())
1831 {
1832 result.prepend("g");
1833 }
1834 }
1835 return result;
1836}
1837
1839{
1840 AUTO_TRACE("name={}",qualifiedName());
1841 bool extractStatic = Config_getBool(EXTRACT_STATIC);
1842 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
1843 m_isLinkableCached = 2; // linkable
1844 //printf("MemberDefImpl::isLinkableInProject(name=%s)\n",qPrint(name()));
1845 if (isHidden())
1846 {
1847 AUTO_TRACE_ADD("is hidden");
1849 return;
1850 }
1851 if (templateMaster())
1852 {
1853 AUTO_TRACE_ADD("has master template");
1855 return;
1856 }
1857 if (isAnonymous())
1858 {
1859 AUTO_TRACE_ADD("name invalid");
1860 m_isLinkableCached = 1; // not a valid or a dummy name
1861 return;
1862 }
1863 if (!hasDocumentation() || isReference())
1864 {
1865 AUTO_TRACE_ADD("no docs or reference");
1866 m_isLinkableCached = 1; // no documentation
1867 return;
1868 }
1869 const GroupDef *groupDef = getGroupDef();
1870 const ClassDef *classDef = getClassDef();
1871 if (groupDef && !groupDef->isLinkableInProject())
1872 {
1873 AUTO_TRACE_ADD("in not linkable group");
1874 m_isLinkableCached = 1; // group but group not linkable
1875 return;
1876 }
1877 if (!groupDef && classDef && !classDef->isLinkableInProject())
1878 {
1879 AUTO_TRACE_ADD("in not linkable class");
1880 m_isLinkableCached = 1; // in class but class not linkable
1881 return;
1882 }
1883 const NamespaceDef *nspace = getNamespaceDef();
1884 const FileDef *fileDef = getFileDef();
1885 if (!groupDef && nspace /*&& m_related==Relationship::Member*/ && !nspace->isLinkableInProject()
1886 && (fileDef==nullptr || !fileDef->isLinkableInProject()))
1887 {
1888 AUTO_TRACE_ADD("in not linkable namespace");
1889 m_isLinkableCached = 1; // in namespace but namespace not linkable
1890 return;
1891 }
1892 if (!groupDef && !nspace &&
1893 /*m_related==Relationship::Member &&*/ !classDef &&
1894 fileDef && !fileDef->isLinkableInProject())
1895 {
1896 AUTO_TRACE_ADD("in not linkable file");
1897 m_isLinkableCached = 1; // in file (and not in namespace) but file not linkable
1898 return;
1899 }
1900 if ((!protectionLevelVisible(m_prot) && m_mtype!=MemberType::Friend) &&
1901 !(m_prot==Protection::Private && (m_virt!=Specifier::Normal || isOverride() || isFinal()) && extractPrivateVirtual))
1902 {
1903 AUTO_TRACE_ADD("private and invisible");
1904 m_isLinkableCached = 1; // hidden due to protection
1905 return;
1906 }
1907 if (m_stat && classDef==nullptr && !extractStatic)
1908 {
1909 AUTO_TRACE_ADD("static and invisible");
1910 m_isLinkableCached = 1; // hidden due to staticness
1911 return;
1912 }
1913 AUTO_TRACE_ADD("linkable");
1914 return; // linkable!
1915}
1916
1922
1928
1933
1938
1944
1950
1952{
1953 if (m_isLinkableCached==0)
1954 {
1955 MemberDefImpl *that = const_cast<MemberDefImpl*>(this);
1957 }
1959 return m_isLinkableCached==2;
1960}
1961
1963{
1964 if (m_templateMaster)
1965 {
1966 return m_templateMaster->isLinkable();
1967 }
1968 else
1969 {
1970 return isLinkableInProject() || isReference();
1971 }
1972}
1973
1974
1979
1981 const ClassDef *,const NamespaceDef *,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
1982 bool onlyText) const
1983{
1984 SrcLangExt lang = getLanguage();
1985 bool hideScopeNames = Config_getBool(HIDE_SCOPE_NAMES);
1986 DString sep = getLanguageSpecificSeparator(lang,true);
1987 DString n = name();
1988 const ClassDef *classDef = getClassDef();
1989 const NamespaceDef *nspace = getNamespaceDef();
1990 if (!hideScopeNames)
1991 {
1992 if (m_enumScope && m_livesInsideEnum && getGroupDef()!=nullptr)
1993 {
1995 }
1996 if (classDef && (gd || mod) && !isRelated())
1997 {
1998 n.prepend(classDef->displayName()+sep);
1999 }
2000 else if (nspace && (gd || fd || mod))
2001 {
2002 n.prepend(nspace->displayName()+sep);
2003 }
2004 }
2005
2006 if (isObjCMethod())
2007 {
2008 if (isStatic()) ol.docify("+ "); else ol.docify("- ");
2009 }
2010 if (!onlyText && (isLinkable() || hasDetailedDescription())) // write link
2011 {
2012 if (m_mtype==MemberType::EnumValue && getGroupDef()==nullptr && // enum value is not grouped
2013 getEnumScope() && getEnumScope()->getGroupDef()) // but its container is
2014 {
2015 const GroupDef *enumValGroup = getEnumScope()->getGroupDef();
2016 ol.writeObjectLink(enumValGroup->getReference(),
2017 enumValGroup->getOutputFileBase(),
2018 anchor(),n);
2019 }
2020 else
2021 {
2023 }
2024 }
2025 else // write only text
2026 {
2027 ol.startBold();
2028 ol.docify(n);
2029 ol.endBold();
2030 }
2031}
2032
2037
2038/*! If this member has an anonymous class/struct/union as its type, then
2039 * this method will return the ClassDef that describes this return type.
2040 */
2045
2046/*! This methods returns true iff the brief section (also known as
2047 * declaration section) is visible in the documentation.
2048 */
2050{
2051 bool extractStatic = Config_getBool(EXTRACT_STATIC);
2052 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
2053 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
2054 bool briefMemberDesc = Config_getBool(BRIEF_MEMBER_DESC);
2055 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
2056 bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
2057
2058 //printf("Member %s grpId=%d docs=%s file=%s args=%s\n",
2059 // qPrint(name()),
2060 // 0,"", //grpId,grpId==-1?"<none>":Doxygen::memberDocDict[grpId]->data(),
2061 // "", //qPrint(getFileDef()->name()),
2062 // argsString());
2063
2064 bool hasDocs = hasDocumentation();
2065
2066 // only include static members with file/namespace scope if
2067 // explicitly enabled in the config file
2068 bool visibleIfStatic = !(getClassDef()==nullptr &&
2069 isStatic() &&
2070 !extractStatic
2071 );
2072
2073 // only include members is the are documented or
2074 // HIDE_UNDOC_MEMBERS is NO in the config file
2075 bool visibleIfDocumented = (!hideUndocMembers ||
2076 hasDocs ||
2078 );
2079
2080 // hide members with no detailed description and brief descriptions
2081 // explicitly disabled.
2082 bool visibleIfEnabled = !(hideUndocMembers &&
2083 documentation().empty() &&
2084 !briefMemberDesc &&
2085 !repeatBrief
2086 );
2087
2088 // Hide friend (class|struct|union) declarations if HIDE_FRIEND_COMPOUNDS is true
2089 bool visibleIfFriendCompound = !(hideFriendCompounds &&
2090 isFriend()
2091 );
2092
2093 // only include members that are non-private unless EXTRACT_PRIVATE is
2094 // set to YES or the member is part of a group. And as a special case,
2095 // private *documented* virtual members are shown if EXTRACT_PRIV_VIRTUAL
2096 // is set to YES
2097 bool visibleIfPrivate = (protectionLevelVisible(protection()) ||
2098 m_mtype==MemberType::Friend ||
2099 (m_prot==Protection::Private &&
2100 (m_virt!=Specifier::Normal || isOverride() || isFinal()) && extractPrivateVirtual && hasDocs)
2101 );
2102
2103 // hide member if it overrides a member in a superclass and has no
2104 // documentation of its own
2105 //bool visibleIfDocVirtual = !reimplements() ||
2106 // !Config_getBool(INHERIT_DOCS) ||
2107 // hasDocs;
2108
2109 // true if this member is a constructor or destructor
2110 bool cOrDTor = isConstructor() || isDestructor();
2111
2112 // hide default constructors or destructors (no args) without
2113 // documentation
2114 bool visibleIfNotDefaultCDTor = !(cOrDTor &&
2115 (m_defArgList.empty() ||
2116 m_defArgList.front().type == "void"
2117 ) &&
2118 !hasDocs
2119 );
2120
2121
2122 //printf("visibleIfStatic=%d visibleIfDocumented=%d visibleIfEnabled=%d "
2123 // "visibleIfPrivate=%d visibleIfNotDefaultCDTor=%d "
2124 // "visibleIfFriendCompound=%d\n",
2125 // visibleIfStatic,visibleIfDocumented,
2126 // visibleIfEnabled,visibleIfPrivate,visibleIfNotDefaultCDTor,
2127 // visibleIfFriendCompound);
2128
2129 bool visible = visibleIfStatic && visibleIfDocumented &&
2130 visibleIfEnabled && visibleIfPrivate &&
2131 /*visibleIfDocVirtual &&*/ visibleIfNotDefaultCDTor &&
2132 visibleIfFriendCompound &&
2133 !isHidden();
2134 //printf("MemberDefImpl::isBriefSectionVisible() %d\n",visible);
2135 return visible;
2136}
2137
2139{
2140 SrcLangExt lang = getLanguage();
2141 DString ltype(m_type);
2142 if (lang==SrcLangExt::Cpp && isEnumerate() && isStrong())
2143 {
2144 if (isEnumStruct())
2145 {
2146 ltype+=" struct";
2147 }
2148 else
2149 {
2150 ltype+=" class";
2151 }
2152 }
2153 if (isTypedef() && getLanguage() != SrcLangExt::Slice)
2154 {
2155 ltype.prepend("typedef ");
2156 }
2157 if (isTypeAlias())
2158 {
2159 if (lang==SrcLangExt::Python)
2160 {
2161 ltype="type";
2162 }
2163 else
2164 {
2165 ltype="using";
2166 }
2167 }
2168 // strip 'friend' keyword from ltype
2169 ltype.stripPrefix("friend ");
2170 if (ltype=="@") // rename type from enum values
2171 {
2172 ltype="";
2173 }
2174 else
2175 {
2176 if (isObjCMethod())
2177 {
2178 ltype.prepend("(");
2179 ltype.append(")");
2180 }
2181 }
2182 return ltype;
2183}
2184
2186 const ArgumentList &al, bool writeReqClause) const
2187{
2188 ol.docify("template<");
2189 LinkifyTextOptions options;
2190 options.setScope(def).setFileScope(getFileDef()).setSelf(this);
2191 for (auto it = al.begin(); it!=al.end();)
2192 {
2193 Argument a = *it;
2194 linkifyText(TextGeneratorOLImpl(ol),a.type,options);
2195 if (!a.name.empty())
2196 {
2197 ol.docify(" ");
2198 ol.docify(a.name);
2199 }
2200 if (!a.defval.empty())
2201 {
2202 ol.docify(" = ");
2203 ol.docify(a.defval);
2204 }
2205 ++it;
2206 if (it!=al.end()) ol.docify(", ");
2207 }
2208 ol.docify("> ");
2209 if (writeReqClause && !m_requiresClause.empty())
2210 {
2211 ol.lineBreak();
2212 ol.docify("requires ");
2214 m_requiresClause, // text
2215 LinkifyTextOptions(options).setAutoBreak(true).setBreakThreshold(120));
2216 }
2217}
2218
2220{
2221 if (exception.empty()) return args; // no exception, nothing to combine args
2222 size_t pos = args.rfind(')');
2223 size_t eqPos = pos!=DString::npos ? args.find('=',pos) : DString::npos; // look for '=' in '(args) = something'
2224 if (eqPos==DString::npos) return args+" "+exception; // append exception at the end
2225 return args.left(eqPos)+" "+exception+" "+args.mid(eqPos); // insert exception before =
2226}
2227
2229{
2230 return !m_bitfields.empty() && name().startsWith("__pad"); // anonymous bitfield
2231}
2232
2234 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
2235 bool inGroup, int indentLevel, const ClassDef *inheritedFrom,const DString &inheritId,
2236 const DString &declAnchor) const
2237{
2238 const DString memAnchor = declAnchor.empty() ? anchor() : declAnchor;
2239 //printf("> %s MemberDefImpl::writeDeclaration() inGroup=%d inheritId=%s\n",qPrint(qualifiedName()),inGroup,qPrint(inheritId));
2240
2241 // hide enum value, since they appear already as part of the enum, unless they
2242 // are explicitly grouped.
2243 if (!inGroup && m_mtype==MemberType::EnumValue) return;
2244
2245 const Definition *d=nullptr;
2246 ASSERT (cd!=nullptr || nd!=nullptr || fd!=nullptr || gd!=nullptr || mod!=nullptr); // member should belong to something
2247 if (cd) d=cd;
2248 else if (nd) d=nd;
2249 else if (fd) d=fd;
2250 else d=gd;
2251 if (d==gd || d==mod) // see bug 753608
2252 {
2253 if (getClassDef()) d = getClassDef();
2254 else if (getNamespaceDef()) d = getNamespaceDef();
2255 else if (getFileDef()) d = getFileDef();
2256 }
2257 else if (d==fd) // see issue #9850, namespace member can be shown in file scope as well
2258 {
2259 if (getNamespaceDef()) d = getNamespaceDef();
2260 }
2261 if (d==nullptr)
2262 {
2263 err("No context could be derived for member '{}'\n",name());
2264 return; // should not happen
2265 }
2266
2267 DString cname = d->name();
2268 DString cdname = d->displayName();
2269 DString cfname = getOutputFileBase();
2270
2271 // search for the last anonymous scope in the member type
2272 const ClassDef *annoClassDef=getClassDefOfAnonymousType();
2273
2275
2276 // start a new member declaration
2279 ol.startMemberItem(annoClassDef && isAnonymous() ? DString() : memAnchor, anonType, inheritId);
2280
2281
2282 // If there is no detailed description we need to write the anchor here.
2283 bool detailsVisible = hasDetailedDescription();
2284 bool writeAnchor = (inGroup || getGroupDef()==nullptr) && // only write anchors for member that have no details and are
2285 !detailsVisible && // rendered inside the group page or are not grouped at all
2286 inheritId.empty();
2287
2288 if (writeAnchor)
2289 {
2290 DString doxyArgs=argsString();
2291 DString doxyName=name();
2292 if (!cname.empty())
2293 {
2295 }
2296 ol.startDoxyAnchor(cfname,cname,memAnchor,doxyName,doxyArgs);
2297 ol.addLabel(cfname,memAnchor);
2298 }
2299
2300 if (!detailsVisible)
2301 {
2302 ol.pushGeneratorState();
2306 ol.docify("\n");
2307 ol.popGeneratorState();
2308 }
2309
2310 if (annoClassDef)
2311 {
2312 for (int j=0;j<indentLevel;j++)
2313 {
2315 }
2316 }
2317
2318 // *** write template lists
2319 if (m_tArgList.hasParameters() && getLanguage()==SrcLangExt::Cpp)
2320 {
2323 ol.endMemberTemplateParams(memAnchor,inheritId);
2324 }
2325
2326
2327 // *** write type
2328 DString ltype(m_type);
2329 auto lang = getLanguage();
2330 if (isTypedef() && lang != SrcLangExt::Slice)
2331 {
2332 ltype.prepend("typedef ");
2333 }
2334 if (isTypeAlias())
2335 {
2336 if (lang==SrcLangExt::Python)
2337 {
2338 ltype="type";
2339 }
2340 else
2341 {
2342 ltype="using";
2343 }
2344 }
2345 // strip 'friend' keyword from ltype
2346 ltype.stripPrefix("friend ");
2347 static const reg::Ex r(R"(@\d+)"); // anonymous type marker
2348 reg::Match match;
2349 std::string stype = ltype.str();
2350 bool endAnonScopeNeeded=false;
2351 LinkifyTextOptions options;
2352 options.setScope(d).setFileScope(getBodyDef()).setSelf(this);
2353 if (reg::search(stype,match,r)) // member has an anonymous type marker
2354 {
2355 //printf("name=%s annoClassDef=%p stype='%s' scopeName='%s'\n",
2356 // qPrint(name()),(void*)annoClassDef,qPrint(stype),qPrint(cname));
2357
2358 static const reg::Ex ar(R"([\w@:]*@\d+[\w@:]*)"); // anonymous type marker(s) including scope
2359 reg::Match amatch;
2360 reg::search(stype,amatch,ar);
2361 size_t ai = amatch.position();
2362 size_t al = amatch.length();
2363 const MemberDef *amd = getAnonymousEnumType();
2364 if (annoClassDef && amd==nullptr) // type is an anonymous compound
2365 {
2366 if (isAnonymous()) // anonymous type without a variable name, e.g. "struct { int x; };" or "union { int x; };"
2367 {
2368 ol.startAnonTypeScope(indentLevel);
2369 annoClassDef->writeDeclaration(ol,inGroup,indentLevel+1,inheritedFrom,inheritId);
2370 //printf(">>>>>>>>>>>>>> startMemberItem(2)\n");
2372 ol.startMemberItem(memAnchor,anonType,inheritId);
2373 for (int j=0;j< indentLevel;j++)
2374 {
2376 }
2377 ol.docify("};");
2378 endAnonScopeNeeded=true;
2379 }
2380 else
2381 {
2382 ol.writeObjectLink(annoClassDef->getReference(),annoClassDef->getOutputFileBase(),
2383 annoClassDef->anchor(),ltype.left(ai)+ltype.mid(ai+al));
2384 }
2385 }
2386 else if (amd) // type is an anonymous enum
2387 {
2388 DString typePlaceholder = " { ... } ";
2389 if (lang==SrcLangExt::Cpp)
2390 {
2391 if (amd->isEnumStruct()) typePlaceholder.prepend(" struct");
2392 else if (amd->isStrong()) typePlaceholder.prepend(" class");
2393 }
2395 amd->anchor(),ltype.left(ai)+typePlaceholder+ltype.mid(ai+al));
2396 }
2397 else // fallback if anonymous type is not found
2398 {
2399 size_t i = match.position();
2400 size_t l = match.length();
2401 ltype = ltype.left(i) + " { ... } " + removeAnonymousScopes(ltype.mid(i+l));
2402 linkifyText(TextGeneratorOLImpl(ol), ltype, options);
2403 }
2404 }
2405 else if (ltype=="@") // rename type from enum values
2406 {
2407 ltype="";
2408 }
2409 else
2410 {
2411 if (isObjCMethod())
2412 {
2413 ltype.prepend("(");
2414 ltype.append(")");
2415 }
2416 linkifyText(TextGeneratorOLImpl(ol),ltype,options);
2417 }
2418
2419 if (!ltype.empty())
2420 {
2421 ol.pushGeneratorState();
2423 ol.docify(" ");
2424 ol.popGeneratorState();
2425 }
2426
2427 if (!isAnonymous())
2428 {
2430 }
2431
2432 // *** write name
2433 if (!isAnonymous() && !_isAnonymousBitField()) // hide anonymous stuff
2434 {
2435 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
2436 bool extractStatic = Config_getBool(EXTRACT_STATIC);
2437 bool visibleIfPrivate = (protectionLevelVisible(protection()) ||
2438 m_mtype==MemberType::Friend ||
2439 (m_prot==Protection::Private &&
2440 (m_virt!=Specifier::Normal || isOverride() || isFinal()) &&
2441 extractPrivateVirtual && hasDocumentation()
2442 ));
2443 //printf("Member name=`%s gd=%p md->groupDef=%p inGroup=%d isLinkable()=%d hasDocumentation=%d\n",qPrint(name()),gd,getGroupDef(),inGroup,isLinkable(),hasDocumentation());
2444 if (!name().empty() && // name valid
2445 (hasDetailedDescription() || isReference()) && // has docs
2446 visibleIfPrivate &&
2447 !(isStatic() && getClassDef()==nullptr && !extractStatic) // hidden due to static-ness
2448 )
2449 {
2450 //printf("writeLink %s->%d\n",qPrint(name),hasDocumentation());
2451 const ClassDef *rcd = cd;
2452 if (isReference() && getClassDef()) rcd = getClassDef();
2453 writeLink(ol,rcd,nd,fd,gd,mod);
2454 }
2455 else if (isDocumentedFriendClass())
2456 // if the member is an undocumented friend declaration for some class,
2457 // then maybe we can link to the class
2458 {
2459 writeLink(ol,getClass(name()),nullptr,nullptr,nullptr,nullptr);
2460 }
2461 else
2462 // there is a brief member description and brief member
2463 // descriptions are enabled or there is no detailed description.
2464 {
2465 const ClassDef *rcd = cd;
2466 if (isReference() && getClassDef()) rcd = getClassDef();
2467 writeLink(ol,rcd,nd,fd,gd,mod,true);
2468 }
2469 }
2470
2471 // *** write arguments
2472 if (!argsString().empty() && !isObjCMethod())
2473 {
2474 if (!isDefine() && !isTypedef()) ol.writeString(" ");
2476 isDefine() ?
2477 substitute(argsString(),",",", ") :
2478 isTypedef() ?
2479 substitute(argsString(),")(",") (") :
2481 LinkifyTextOptions(options)
2482 .setArgumentList(&m_defArgList)
2483 .setAutoBreak(false)
2484 .setIndentLevel(indentLevel)
2485 );
2486 }
2487
2488 // *** write bitfields
2489 if (!m_bitfields.empty()) // add bitfields
2490 {
2492 }
2493 else if (hasOneLineInitializer()
2494 //!init.empty() && initLines==0 && // one line initializer
2495 //((maxInitLines>0 && userInitLines==-1) || userInitLines>0) // enabled by default or explicitly
2496 ) // add initializer
2497 {
2498 if (isTypeAlias()) // using statement
2499 {
2500 ol.writeString(" = ");
2502 }
2503 else if (!isDefine())
2504 {
2505 //ol.writeString(" = ");
2506 ol.writeString(" ");
2508 }
2509 else
2510 {
2513 }
2514 }
2515
2516
2518 {
2519 ol.startTypewriter();
2520 ol.docify(" [implementation]");
2521 ol.endTypewriter();
2522 }
2523
2524 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
2525
2526 if (isProperty() && (isSettable() || isGettable() ||
2529 {
2530 ol.writeLatexSpacing();
2531 ol.startTypewriter();
2532 ol.docify(" [");
2533 StringVector sl;
2534
2535 if (isGettable()) sl.emplace_back("get");
2536 if (isProtectedGettable()) sl.emplace_back("protected get");
2537 if (isSettable()) sl.emplace_back("set");
2538 if (isProtectedSettable()) sl.emplace_back("protected set");
2539 if (isInitonly()) sl.emplace_back("init");
2540 if (extractPrivate)
2541 {
2542 if (isPrivateGettable()) sl.emplace_back("private get");
2543 if (isPrivateSettable()) sl.emplace_back("private set");
2544 }
2545 bool first=true;
2546 for (const auto &s : sl)
2547 {
2548 if (!first)
2549 {
2550 ol.docify(", ");
2551 }
2552 first=false;
2553 ol.docify(s);
2554 }
2555 ol.docify("]");
2556 ol.endTypewriter();
2557 }
2558
2559 if (isEvent() && (isAddable() || isRemovable() || isRaisable()))
2560 {
2561 ol.writeLatexSpacing();
2562 ol.startTypewriter();
2563 ol.docify(" [");
2564 StringVector sl;
2565 if (isAddable()) sl.emplace_back("add");
2566 if (isRemovable()) sl.emplace_back("remove");
2567 if (isRaisable()) sl.emplace_back("raise");
2568 bool first=true;
2569 for (const auto &s : sl)
2570 {
2571 if (!first)
2572 {
2573 ol.docify(", ");
2574 }
2575 first=false;
2576 ol.docify(s);
2577 }
2578 ol.docify("]");
2579 ol.endTypewriter();
2580 }
2581
2582 if (writeAnchor)
2583 {
2584 ol.endDoxyAnchor(cfname,memAnchor);
2585 }
2586
2587 //printf("endMember %s annoClassDef=%p annEnumType=%p\n",
2588 // qPrint(name()),annoClassDef,annEnumType);
2589 ol.endMemberItem(anonType);
2590 if (endAnonScopeNeeded)
2591 {
2592 ol.endAnonTypeScope(indentLevel);
2593 }
2594
2595 // write brief description
2596 if (!briefDescription().empty() &&
2597 Config_getBool(BRIEF_MEMBER_DESC)
2598 )
2599 {
2600 auto parser { createDocParser() };
2601 auto ast { validatingParseDoc(*parser.get(),
2602 briefFile(),
2603 briefLine(),
2605 this,
2607 DocOptions()
2608 .setIndexWords(inheritedFrom==nullptr)
2609 .setSingleLine(true))
2610 };
2611 if (!ast->empty())
2612 {
2613 ol.startMemberDescription(memAnchor,inheritId);
2614 ol.writeDoc(ast.get(),getOuterScope()?getOuterScope():d,this);
2615 if (detailsVisible) // add More.. link only when both brief and details are visible
2616 {
2617 if (!isAnonymous()) // hide anonymous stuff
2618 {
2619 ol.pushGeneratorState();
2621 ol.docify(" ");
2622 ol.popGeneratorState();
2623 }
2624 }
2625 // for RTF we need to add an extra empty paragraph
2626 ol.pushGeneratorState();
2628 ol.startParagraph();
2629 ol.endParagraph();
2630 ol.popGeneratorState();
2632 }
2633 }
2634
2635 ol.endMemberDeclaration(memAnchor,inheritId);
2636
2638 //printf("< %s MemberDefImpl::writeDeclaration() inGroup=%d\n",qPrint(qualifiedName()),inGroup);
2639}
2640
2642
2644{
2645 std::lock_guard<std::mutex> lock(g_hasDetailedDescriptionMutex);
2646 //printf(">hasDetailedDescription(cached=%d)\n",m_hasDetailedDescriptionCached);
2648 {
2649 bool extractAll = Config_getBool(EXTRACT_ALL);
2650 bool alwaysDetailedSec = Config_getBool(ALWAYS_DETAILED_SEC);
2651 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
2652 bool briefMemberDesc = Config_getBool(BRIEF_MEMBER_DESC);
2653 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
2654 bool extractStatic = Config_getBool(EXTRACT_STATIC);
2655 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
2656 bool inlineSources = hasInlineSource();
2657 bool includes = Config_getBool(SHOW_INCLUDE_FILES) && m_incInfo!=nullptr;
2658
2659 // the member has detailed documentation because the user added some comments
2660 bool docFilter =
2661 // extract all is enabled
2662 extractAll ||
2663 // has detailed docs
2664 !documentation().empty() ||
2665 // has inbody docs
2667 // is an enum with values that are documented
2669 // is documented enum value
2670 (m_mtype==MemberType::EnumValue && !briefDescription().empty()) ||
2671 // has brief description that is part of the detailed description
2672 (!briefDescription().empty() && // has brief docs
2673 (alwaysDetailedSec && // they are visible in
2674 (repeatBrief || // detailed section or
2675 !briefMemberDesc // they are explicitly not
2676 ) // shown in brief section
2677 )
2678 ) ||
2679 // has one or more documented arguments
2684 m_templateMaster->templateArguments().hasTemplateDocumentation() :
2686 // user-specified qualifiers
2687 !m_qualifiers.empty();
2688
2689 // generate function guard
2690 // ================== =======
2691 // _writeGroupInclude -> ignored in calculation
2692 // multiLineInitializer() -> hasMultiLineInitializer()
2693 // _writeReimplements -> _isReimplements()
2694 // _writeReimplementedBy -> _countReimplementedBy()>0
2695 // _writeExamples -> hasExamples()
2696 // _writeTypeConstraints -> m_typeConstraints.hasParameters()
2697 // writeSourceDef -> !getSourceFileBase().empty();
2698 // writeInlineCode -> hasInlineSource() && hasSources()
2699 // writeSourceRefs -> hasReferencesRelation() && hasSourceRefs()
2700 // writeSourceReffedBy -> hasReferencedByRelation() && hasSourceReffedBy()
2701 // _writeCallGraph -> _hasVisibleCallGraph()
2702 // _writeCallerGraph -> _hasVisibleCallerGraph()
2703
2704 // the member has detailed documentation because there is some generated info
2705 bool docInfo =
2706 // has a multi-line initialization block
2708 // reimplements / reimplemented by
2710 // examples
2711 hasExamples() ||
2712 // type constraints
2714 // has source definition
2715 !getSourceFileBase().empty() ||
2716 // has inline sources
2717 (inlineSources && hasSources()) ||
2718 // has references
2721 // call graph
2723 // caller graph
2725 // requirement references
2727 // has \headerfile command
2728 includes;
2729
2730 if (!hideUndocMembers) // if HIDE_UNDOC_MEMBERS is NO we also show the detailed section
2731 // if there is only some generated info
2732 {
2733 docFilter = docFilter || docInfo;
2734 }
2735
2736 // this is not a global static or global statics should be extracted
2737 bool staticFilter = getClassDef()!=nullptr || !isStatic() || extractStatic;
2738
2739 // a module does not contain details for members, so either the namespace or file should be linkable
2740 bool moduleFilter = getModuleDef()==nullptr || (getFileDef() && getFileDef()->isLinkable()) ||
2743
2744 // only include members that are non-private unless EXTRACT_PRIVATE is
2745 // set to YES or the member is part of a group
2746 bool privateFilter = protectionLevelVisible(protection()) || m_mtype==MemberType::Friend ||
2747 (m_prot==Protection::Private && (m_virt!=Specifier::Normal || isOverride() || isFinal()) && extractPrivateVirtual);
2748
2749 // hide friend (class|struct|union) member if HIDE_FRIEND_COMPOUNDS
2750 // is true
2751 bool friendCompoundFilter = !(Config_getBool(HIDE_FRIEND_COMPOUNDS) && isFriend());
2752
2754 (docFilter && staticFilter && moduleFilter && privateFilter && friendCompoundFilter && !isHidden());
2755 //printf("docFilter=%d docInfo=%d staticFilter=%d privateFilter=%d friendCompoundFilter=%d !isHidden()=%d",
2756 // docFilter,docInfo,staticFilter,privateFilter,friendCompoundFilter,!isHidden());
2758 }
2759 //printf("<hasDetailedDescription(cached=%d)\n",m_hasDetailedDescriptionCached);
2761}
2762
2764{
2765 bool separateMemPages = Config_getBool(SEPARATE_MEMBER_PAGES);
2766 bool inlineSimpleStructs = Config_getBool(INLINE_SIMPLE_STRUCTS);
2767 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
2768 bool groupFilter = getGroupDef()==nullptr || container==MemberListContainer::Group || separateMemPages;
2769 bool fileFilter = getNamespaceDef()==nullptr || !getNamespaceDef()->isLinkable() || container!=MemberListContainer::File;
2770 bool simpleFilter = (hasBriefDescription() || !hideUndocMembers) && inlineSimpleStructs &&
2771 getClassDef()!=nullptr && getClassDef()->isSimple();
2772
2773 bool visible = hasDetailedDescription() && groupFilter && fileFilter &&
2774 !isReference();
2775 bool result = visible || simpleFilter;
2776 //printf("%s::isDetailedSectionVisible: %d groupFilter=%d fileFilter=%d\n",
2777 // qPrint(name()),result,groupFilter,fileFilter);
2778 return result;
2779}
2780
2782{
2783 StringVector sl;
2784 bool inlineInfo = Config_getBool(INLINE_INFO);
2785 bool inherited = getClassDef() &&
2786 (getClassDef()!=container || m_explicitInherited) &&
2787 container->definitionType()==TypeClass &&
2788 !isRelated();
2789 Specifier lvirt=virtualness();
2790 if ((!isObjCMethod() || isOptional() || isRequired()) &&
2791 (protection()!=Protection::Public || lvirt!=Specifier::Normal ||
2792 isFriend() || isRelated() ||
2793 (isInline() && inlineInfo) ||
2794 isSignal() || isSlot() ||
2795 isStatic() || isExternal() ||
2796 isExported() ||
2797 inherited ||
2798 TypeSpecifier(m_memSpec).setInline(false)!=TypeSpecifier()
2799 )
2800 )
2801 {
2802 // write the member specifier list
2803 //ol.writeLatexSpacing();
2804 //ol.startTypewriter();
2805 //ol.docify(" [");
2806 SrcLangExt lang = getLanguage();
2807 bool optVhdl = lang==SrcLangExt::VHDL;
2808 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
2809 if (optVhdl)
2810 {
2811 sl.push_back(theTranslator->trVhdlType(getVhdlSpecifiers(),true).str());
2812 }
2813 else
2814 {
2815 if (isFriend()) sl.emplace_back("friend");
2816 else if (isRelated()) sl.emplace_back("related");
2817 else
2818 {
2819 if (isExternal()) sl.emplace_back("extern");
2820 if (inlineInfo && isInline()) sl.emplace_back("inline");
2821 if (isExplicit()) sl.emplace_back("explicit");
2822 if (isMutable()) sl.emplace_back("mutable");
2823 if (isThreadLocal()) sl.emplace_back("thread_local");
2824 if (isStatic()) sl.emplace_back("static");
2825 if (isGettable()) sl.emplace_back("get");
2826 if (isProtectedGettable()) sl.emplace_back("protected get");
2827 if (isSettable()) sl.emplace_back("set");
2828 if (isProtectedSettable()) sl.emplace_back("protected set");
2829 if (isProperty() && isInitonly()) sl.emplace_back("init");
2830 if (extractPrivate)
2831 {
2832 if (isPrivateGettable()) sl.emplace_back("private get");
2833 if (isPrivateSettable()) sl.emplace_back("private set");
2834 }
2835 if (isNoDiscard()) sl.emplace_back("nodiscard");
2836 if (isConstExpr()) sl.emplace_back("constexpr");
2837 if (isConstEval()) sl.emplace_back("consteval");
2838 if (isConstInit()) sl.emplace_back("constinit");
2839 if (isAddable()) sl.emplace_back("add");
2840 if (!isUNOProperty() && isRemovable()) sl.emplace_back("remove");
2841 if (isRaisable()) sl.emplace_back("raise");
2842 if (isReadable()) sl.emplace_back("read");
2843 if (isWritable()) sl.emplace_back("write");
2844 if (isFinal()) sl.emplace_back("final");
2845 if (isAbstract()) sl.emplace_back("abstract");
2846 if (isOverride()) sl.emplace_back("override");
2847 if (!isProperty() && isInitonly()) sl.emplace_back("initonly");
2848 if (isSealed()) sl.emplace_back("sealed");
2849 if (isNew()) sl.emplace_back("new");
2850 if (isOptional()) sl.emplace_back("optional");
2851 if (isRequired()) sl.emplace_back("required");
2852 if (isExported()) sl.emplace_back("export");
2853
2854 if (isNonAtomic()) sl.emplace_back("nonatomic");
2855 else if (isObjCProperty()) sl.emplace_back("atomic");
2856
2857 // mutual exclusive Objective 2.0 property attributes
2858 if (isAssign()) sl.emplace_back("assign");
2859 else if (isCopy()) sl.emplace_back("copy");
2860 else if (isRetain()) sl.emplace_back("retain");
2861 else if (isWeak()) sl.emplace_back("weak");
2862 else if (lang!=SrcLangExt::CSharp && isStrong()) sl.emplace_back("strong");
2863 else if (isUnretained()) sl.emplace_back("unsafe_unretained");
2864
2865 if (!isObjCMethod())
2866 {
2867 if (protection()==Protection::Protected) sl.emplace_back("protected");
2868 else if (protection()==Protection::Private) sl.emplace_back("private");
2869 else if (protection()==Protection::Package) sl.emplace_back("package");
2870
2871 if (lvirt==Specifier::Virtual) sl.emplace_back("virtual");
2872 else if (lvirt==Specifier::Pure) sl.emplace_back("pure virtual");
2873 if (isSignal()) sl.emplace_back("signal");
2874 if (isSlot()) sl.emplace_back("slot");
2875 if (isDefault()) sl.emplace_back("default");
2876 if (isDelete()) sl.emplace_back("delete");
2877 if (isNoExcept()) sl.emplace_back("noexcept");
2878 if (isAttribute()) sl.emplace_back("attribute");
2879 if (isUNOProperty()) sl.emplace_back("property");
2880 if (isReadonly()) sl.emplace_back("readonly");
2881 if (isBound()) sl.emplace_back("bound");
2882 if (isUNOProperty() && isRemovable()) sl.emplace_back("removable");
2883 if (isConstrained()) sl.emplace_back("constrained");
2884 if (isTransient()) sl.emplace_back("transient");
2885 if (isMaybeVoid()) sl.emplace_back("maybevoid");
2886 if (isMaybeDefault()) sl.emplace_back("maybedefault");
2887 if (isMaybeAmbiguous()) sl.emplace_back("maybeambiguous");
2888 if (isPublished()) sl.emplace_back("published"); // enum
2889 }
2891 {
2892 sl.emplace_back("implementation");
2893 }
2894 }
2895 if (inherited)
2896 {
2897 sl.emplace_back("inherited");
2898 }
2899 }
2900 }
2901 else if (isObjCMethod() && isImplementation())
2902 {
2903 sl.emplace_back("implementation");
2904 }
2905
2906 for (const auto &sx : m_qualifiers)
2907 {
2908 bool alreadyAdded = std::find(sl.begin(), sl.end(), sx) != sl.end();
2909 if (!alreadyAdded)
2910 {
2911 sl.push_back(sx);
2912 }
2913 }
2914
2915 return sl;
2916}
2917
2919{
2920 // write call graph
2922 {
2923 DotCallGraph callGraph(this,false);
2924 if (callGraph.isTooBig())
2925 {
2926 warn_uncond("Call graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
2927 qualifiedName(), callGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
2928 }
2929 else if (!callGraph.isTrivial())
2930 {
2931 msg("Generating call graph for function {}\n",qualifiedName());
2933 ol.startCallGraph();
2935 ol.endCallGraph(callGraph);
2936 ol.enableAll();
2937 }
2938 }
2939}
2940
2942{
2944 {
2945 DotCallGraph callerGraph(this, true);
2946 if (callerGraph.isTooBig())
2947 {
2948 warn_uncond("Caller graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
2949 qualifiedName(), callerGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
2950 }
2951 else if (!callerGraph.isTrivial())
2952 {
2953 msg("Generating caller graph for function {}\n",qualifiedName());
2955 ol.startCallGraph();
2957 ol.endCallGraph(callerGraph);
2958 ol.enableAll();
2959 }
2960 }
2961}
2962
2964{
2965 const MemberDef *bmd=reimplements();
2966 const ClassDef *bcd=nullptr;
2967 if (bmd && (bcd=bmd->getClassDef()))
2968 {
2969 // write class that contains a member that is reimplemented by this one
2970 if (bcd->isLinkable())
2971 {
2972 return true;
2973 }
2974 }
2975 return false;
2976}
2978{
2979 const MemberDef *bmd=reimplements();
2980 const ClassDef *bcd=nullptr;
2981 if (bmd && (bcd=bmd->getClassDef()))
2982 {
2983 // write class that contains a member that is reimplemented by this one
2984 if (bcd->isLinkable())
2985 {
2986 ol.startParagraph();
2987 DString reimplFromLine;
2988 if (bmd->virtualness()!=Specifier::Pure && bcd->compoundType()!=ClassDef::Interface)
2989 {
2990 reimplFromLine = theTranslator->trReimplementedFromList(1);
2991 }
2992 else
2993 {
2994 reimplFromLine = theTranslator->trImplementedFromList(1);
2995 }
2996 if (size_t markerPos = reimplFromLine.find("@0"); markerPos!=DString::npos) // should always pass this.
2997 {
2998 ol.parseText(reimplFromLine.left(markerPos)); //text left from marker
2999 if (bmd->isLinkable()) // replace marker with link
3000 {
3001 //Definition *bd=bmd->group;
3002 //if (bd==0) bd=bcd;
3004 bmd->anchor(),bcd->displayName());
3005
3006 //ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
3007 // bmd->anchor(),bcd->name());
3008 if ( bmd->isLinkableInProject() )
3009 {
3010 writePageRef(ol,bmd->getOutputFileBase(),bmd->anchor());
3011 }
3012 }
3013 else
3014 {
3016 DString(),bcd->displayName());
3017 if (bcd->isLinkableInProject()/* && !Config_getBool(PDF_HYPERLINKS)*/ )
3018 {
3019 writePageRef(ol,bcd->getOutputFileBase(),bcd->anchor());
3020 }
3021 }
3022 ol.parseText(reimplFromLine.right(
3023 reimplFromLine.length()-markerPos-2)); // text right from marker
3024
3025 }
3026 else
3027 {
3028 err("translation error: no marker in trReimplementsFromList()\n");
3029 }
3030 ol.endParagraph();
3031 }
3032 }
3033}
3034
3036{
3037 const MemberVector &bml=reimplementedBy();
3038 size_t count=0;
3039 for (const auto &bmd : bml)
3040 {
3041 const ClassDef *bcd=bmd->getClassDef();
3042 // count the members that directly inherit from md and for
3043 // which the member and class are visible in the docs.
3044 if ( bcd && bmd->isLinkable() && bcd->isLinkable() )
3045 {
3046 count++;
3047 }
3048 }
3049 return count;
3050}
3051
3053{
3054 const MemberVector &bml=reimplementedBy();
3055 size_t count = _countReimplementedBy();
3056 if (count>0)
3057 {
3058 auto replaceFunc = [&bml,&ol](size_t entryIndex)
3059 {
3060 size_t cnt=0;
3061 auto it = bml.begin();
3062 // find the entryIndex-th documented entry in the inheritance list.
3063 const MemberDef *bmd = nullptr;
3064 const ClassDef *bcd = nullptr;
3065 while (it!=bml.end())
3066 {
3067 bmd = *it;
3068 bcd = bmd->getClassDef();
3069 if ( bmd->isLinkable() && bcd->isLinkable())
3070 {
3071 if (cnt==entryIndex) break;
3072 cnt++;
3073 }
3074 ++it;
3075 }
3076
3077 if (bcd && bmd) // write link for marker
3078 {
3079 //ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
3080 // bmd->anchor(),bcd->name());
3082 bmd->anchor(),bcd->displayName());
3083
3084 if (bmd->isLinkableInProject() )
3085 {
3086 writePageRef(ol,bmd->getOutputFileBase(),bmd->anchor());
3087 }
3088 }
3089 };
3090
3091 DString reimplInLine;
3092 if (m_virt==Specifier::Pure || (getClassDef() && getClassDef()->compoundType()==ClassDef::Interface))
3093 {
3094 reimplInLine = theTranslator->trImplementedInList(static_cast<int>(count));
3095 }
3096 else
3097 {
3098 reimplInLine = theTranslator->trReimplementedInList(static_cast<int>(count));
3099 }
3100
3101 // write the list of classes that overwrite this member
3102 ol.startParagraph();
3103 writeMarkerList(ol,
3104 reimplInLine.str(),
3105 count,
3106 replaceFunc);
3107 ol.endParagraph();
3108 }
3109}
3110
3112{
3113 if (getClassDef()) // this should be a member of a class/category
3114 {
3115 //printf("%s: category %s relation %s class=%s categoryOf=%s\n",
3116 // qPrint(name()),
3117 // m_category ? qPrint(m_category->name()) : "<none>",
3118 // m_categoryRelation ? qPrint(m_categoryRelation->name()) : "<none>",
3119 // qPrint(m_classDef->name()),
3120 // m_classDef->categoryOf() ? qPrint(m_classDef->categoryOf()->name()) : "<none>"
3121 // );
3122 DString text;
3123 DString ref;
3124 DString file;
3125 DString anc;
3126 DString name;
3127 size_t i=DString::npos;
3129 {
3130 if (m_category)
3131 {
3132 // this member is in a normal class and implements method categoryRelation from category
3133 // so link to method 'categoryRelation' with 'provided by category 'category' text.
3136 }
3137 else if (getClassDef()->categoryOf())
3138 {
3139 // this member is part of a category so link to the corresponding class member of the class we extend
3140 // so link to method 'categoryRelation' with 'extends class 'classDef->categoryOf()'
3141 text = theTranslator->trExtendsClass();
3143 }
3144 i=text.find("@0");
3145 if (i!=DString::npos)
3146 {
3147 const MemberDef *md = m_categoryRelation;
3148 ref = md->getReference();
3149 file = md->getOutputFileBase();
3150 anc = md->anchor();
3151 }
3152 }
3153 if (i!=DString::npos && !name.empty())
3154 {
3155 ol.startParagraph();
3156 ol.parseText(text.left(i));
3157 ol.writeObjectLink(ref,file,anc,name);
3158 ol.parseText(text.mid(i+2));
3159 ol.endParagraph();
3160 }
3161 }
3162}
3163
3165{
3166 // write the list of examples that use this member
3167 if (hasExamples())
3168 {
3169 ol.startExamples();
3170 ol.startDescForItem();
3172 ol.endDescForItem();
3173 ol.endExamples();
3174 }
3175}
3176
3184
3186 const DString &cfname,const DString &ciname,
3187 const DString &cname) const
3188{
3189 // For enum, we also write the documented enum values
3190 if (isEnumerate())
3191 {
3192 bool first=true;
3193 //printf("** %s: enum values=%zu\n",qPrint(name()),enumFieldList().size());
3194 bool hasInits = false;
3195 if (hasEnumValues())
3196 {
3197 for (const auto &fmd : enumFieldList())
3198 {
3199 if (fmd->isLinkable())
3200 {
3201 if (!fmd->initializer().empty())
3202 {
3203 hasInits = true;
3204 break;
3205 }
3206 }
3207 }
3208 }
3209 for (const auto &fmd : enumFieldList())
3210 {
3211 //printf("Enum %p: isLinkable()=%d\n",fmd,fmd->isLinkable());
3212 if (fmd->isLinkable())
3213 {
3214 if (first)
3215 {
3217 first=false;
3218 }
3219
3220 ol.startDescTableRow();
3221 ol.addIndexItem(fmd->name(),ciname);
3222 ol.addIndexItem(ciname,fmd->name());
3223
3225 ol.startDoxyAnchor(cfname,cname,fmd->anchor(),fmd->name(),fmd->argsString());
3226 ol.addLabel(cfname,fmd->anchor());
3227 ol.docify(fmd->name());
3229 ol.writeString(" ");
3230 ol.enableAll();
3231 ol.endDoxyAnchor(cfname,fmd->anchor());
3232 ol.endDescTableTitle();
3233 if (hasInits)
3234 {
3235 ol.startDescTableInit();
3236 if (!fmd->initializer().empty())
3237 {
3238 DString initStr = fmd->initializer().stripWhiteSpace();
3239 if (initStr.startsWith("=")) initStr = initStr.mid(1).stripWhiteSpace();
3241 ol.writeString("(");
3242 ol.enableAll();
3243 ol.docify(initStr);
3245 ol.writeString(")");
3246 ol.enableAll();
3247 }
3248 ol.endDescTableInit();
3249 }
3250 ol.startDescTableData();
3251
3252 bool hasBrief = !fmd->briefDescription().empty();
3253 bool hasDetails = !fmd->documentation().empty();
3254
3255 if (hasBrief)
3256 {
3257 ol.generateDoc(fmd->briefFile(),
3258 fmd->briefLine(),
3259 getOuterScope()?getOuterScope():container,
3260 fmd,
3261 fmd->briefDescription(),
3262 DocOptions()
3263 .setIndexWords(true));
3264 }
3265 if (hasDetails)
3266 {
3267 ol.generateDoc(fmd->docFile(),
3268 fmd->docLine(),
3269 getOuterScope()?getOuterScope():container,
3270 fmd,
3271 fmd->documentation()+"\n",
3272 DocOptions()
3273 .setIndexWords(true));
3274 }
3275 ol.endDescTableData();
3276 ol.endDescTableRow();
3277 }
3278 }
3279 if (!first)
3280 {
3281 ol.endDescTable();
3282 }
3283 }
3284}
3285
3286// match from the start of the scope until the last marker
3287static const reg::Ex reAnonymous(R"([\w:@]*@\d+)");
3288
3290{
3291 DString ldef = definition();
3292 DString title = name();
3293 if (isEnumerate())
3294 {
3295 if (isAnonymous())
3296 {
3297 ldef = title = "anonymous enum";
3298 if (!m_enumBaseType.empty())
3299 {
3300 ldef+=" : "+m_enumBaseType;
3301 }
3302 }
3303 else
3304 {
3305 ldef.prepend("enum ");
3306 if (isSliceLocal())
3307 {
3308 ldef.prepend("local ");
3309 }
3310 }
3311 }
3312 else if (isEnumValue())
3313 {
3314 if (isAnonymous())
3315 {
3316 ldef=ldef.mid(2);
3317 }
3318 }
3319
3320 std::string sdef = ldef.str();
3321 reg::Match match;
3322 if (reg::search(sdef,match,reAnonymous))
3323 {
3324 const ClassDef *annoClassDef=getClassDefOfAnonymousType();
3325 if (annoClassDef)
3326 {
3327 static const reg::Ex ar(R"([\w@:]*@\d+[\w@:]*)");
3328 reg::Match amatch;
3329 reg::search(sdef,amatch,ar);
3330 ldef = amatch.prefix().str() + annoClassDef->displayName() + amatch.suffix().str();
3331 }
3332 else
3333 {
3334 ldef = match.prefix().str() + " { ... } " + removeAnonymousScopes(match.suffix().str());
3335 }
3336 }
3337
3338 const ClassDef *cd=getClassDef();
3339 if (cd && cd->isObjectiveC())
3340 {
3341 // strip scope name
3342 if (size_t ep = ldef.find("::"); ep!=DString::npos)
3343 {
3344 if (size_t sp=ldef.rfind(' ',ep); sp!=DString::npos)
3345 {
3346 ldef=ldef.left(sp+1)+ldef.mid(ep+2);
3347 }
3348 }
3349 // strip keywords
3350 if (size_t dp = ldef.find(':'); dp!=DString::npos)
3351 {
3352 ldef=ldef.left(dp+1);
3353 }
3354 int l=static_cast<int>(ldef.length());
3355 //printf("start >%s<\n",qPrint(ldef));
3356 int i=l-1;
3357 while (i>=0 && (isId(ldef.at(i)) || ldef.at(i)==':')) i--;
3358 while (i>=0 && isspace(static_cast<uint8_t>(ldef.at(i)))) i--;
3359 if (i>0)
3360 {
3361 // insert branches around the type
3362 ldef = "("+ldef.left(i+1)+")"+ldef.mid(i+1);
3363 }
3364 //printf("end >%s< i=%d\n",qPrint(ldef),i);
3365 if (isStatic()) ldef.prepend("+ "); else ldef.prepend("- ");
3366 }
3367 SrcLangExt lang = getLanguage();
3368 DString sep = getLanguageSpecificSeparator(lang,true);
3369 return substitute(ldef,"::",sep);
3370}
3371
3373{
3374 SrcLangExt lang = getLanguage();
3375 bool written = false;
3376 if (m_incInfo) // explicit \headerfile command
3377 {
3378 DString nm=m_incInfo->includeName.empty() ?
3379 (m_incInfo->fileDef ?
3380 m_incInfo->fileDef->docName() : DString()
3381 ) : m_incInfo->includeName;
3382 if (!nm.empty())
3383 {
3384 ol.startParagraph();
3385 ol.startTypewriter();
3386 ol.docify(::includeStatement(lang,m_incInfo->kind));
3387 ol.docify(::includeOpen(lang,m_incInfo->kind));
3388 ol.pushGeneratorState();
3390 ol.docify(nm);
3393 if (m_incInfo->fileDef)
3394 {
3395 ol.writeObjectLink(DString(),m_incInfo->fileDef->includeName(),DString(),nm);
3396 }
3397 else
3398 {
3399 ol.docify(nm);
3400 }
3401 ol.popGeneratorState();
3402 ol.docify(::includeClose(lang,m_incInfo->kind));
3403 ol.endTypewriter();
3404 ol.endParagraph();
3405 written = true;
3406 }
3407 }
3408 if (!written) // only write out the include file if this is not part of a class or file definition
3409 {
3410 bool showGroupedMembInc = Config_getBool(SHOW_GROUPED_MEMB_INC);
3411 bool forceLocalIncludes = Config_getBool(FORCE_LOCAL_INCLUDES);
3412 const FileDef *fd = getFileDef();
3413 DString nm;
3414 if (inGroup && fd && showGroupedMembInc)
3415 {
3416 if (!Config_getList(STRIP_FROM_INC_PATH).empty())
3417 {
3419 }
3420 else
3421 {
3422 nm = fd->name();
3423 }
3424 }
3425 if (!nm.empty())
3426 {
3427 ol.startParagraph();
3428 ol.startTypewriter();
3429 bool isIDLorJava = lang==SrcLangExt::IDL || lang==SrcLangExt::Java;
3430 if (isIDLorJava)
3431 {
3432 ol.docify("import ");
3433 }
3434 else
3435 {
3436 ol.docify("#include ");
3437 }
3438
3439 if (isIDLorJava || forceLocalIncludes) ol.docify("\""); else ol.docify("<");
3440
3441 if (fd && fd->isLinkable())
3442 {
3443 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),fd->anchor(),nm);
3444 }
3445 else
3446 {
3447 ol.docify(nm);
3448 }
3449
3450 if (isIDLorJava || forceLocalIncludes) ol.docify("\""); else ol.docify(">");
3451
3452 ol.endTypewriter();
3453 ol.endParagraph();
3454 }
3455 }
3456}
3457
3459{
3460 //printf("md=%s initLines=%d init='%s'\n",qPrint(name()),initLines,qPrint(init));
3461 ol.startBold();
3462 if (m_mtype==MemberType::Define)
3464 else
3466 ol.endBold();
3467 DString langCorrected = getDefFileExtension();
3469 if (srcLangExt == SrcLangExt::Lex)
3470 {
3471 langCorrected = ".doxygen_lex_c";
3472 srcLangExt = SrcLangExt::Cpp;
3473 }
3474 auto intf = Doxygen::parserManager->getCodeParser(langCorrected);
3475 intf->resetCodeParserState();
3476 auto &codeOL = ol.codeGenerators();
3477 codeOL.startCodeFragment("DoxyCode");
3478 intf->parseCode(codeOL,scopeName,m_initializer,srcLangExt,Config_getBool(STRIP_CODE_COMMENTS),
3481 .setInlineFragment(true)
3482 .setMemberDef(this)
3483 .setShowLineNumbers(false)
3484 .setSearchCtx(this)
3485 );
3486 codeOL.endCodeFragment("DoxyCode");
3487}
3488
3489/*! Writes the "detailed documentation" section of this member to
3490 * all active output formats.
3491 */
3493 int memCount,int memTotal,
3494 OutputList &ol,
3495 const DString &scName,
3496 const Definition *container,
3497 bool inGroup,
3498 bool /* showEnumValues */,
3499 bool showInline
3500 ) const
3501{
3502 // if this member is in a group find the real scope name.
3503 bool hasParameterList = false;
3504
3505 //printf("MemberDefImpl::writeDocumentation(): name='%s' hasDocs='%d' containerType=%d inGroup=%d sectionLinkable=%d\n",
3506 // qPrint(name()),hasDocs,container->definitionType(),inGroup,hasDetailedDescription());
3507
3508 //if ( !hasDocs ) return;
3509 //if (isEnumValue() && !showEnumValues) return;
3510
3511 SrcLangExt lang = getLanguage();
3512 //printf("member=%s lang=%d\n",qPrint(name()),lang);
3513 bool optVhdl = lang==SrcLangExt::VHDL;
3514 DString sep = getLanguageSpecificSeparator(lang,true);
3515
3516 DString scopeName = scName;
3517 DString memAnchor = anchor();
3518 DString ciname = container->displayName();
3519 const Definition *scopedContainer = container; // see bug 753608
3520 if (container->definitionType()==TypeGroup)
3521 {
3522 if (getClassDef()) { scopeName=getClassDef()->displayName(); scopedContainer=getClassDef(); }
3523 else if (getNamespaceDef()) { scopeName=getNamespaceDef()->displayName(); scopedContainer=getNamespaceDef(); }
3524 else if (getFileDef()) { scopeName=getFileDef()->displayName(); scopedContainer=getFileDef(); }
3525 ciname = (toGroupDef(container))->groupTitle();
3526 }
3527 else if (container->definitionType()==TypeFile && getNamespaceDef() && getNamespaceDef()->isLinkable())
3528 { // member is in a namespace, but is written as part of the file documentation
3529 // as well, so we need to make sure its anchor is unique (it is not really used).
3530 memAnchor.prepend("file_");
3531 }
3532
3533 DString cname = container->name();
3534 DString cfname = getOutputFileBase();
3535
3536 // get member name
3537 DString doxyName=name();
3538 // prepend scope if there is any. TODO: make this optional for C only docs
3539 if (!scopeName.empty())
3540 {
3541 doxyName.prepend(scopeName+sep);
3542 }
3543 DString doxyArgs=argsString();
3544
3545 DString ldef = definition();
3546 DString title = name();
3547
3548 //printf("member '%s' def='%s'\n",qPrint(name()),qPrint(ldef));
3549 if (isEnumerate())
3550 {
3551 if (title.at(0)=='@')
3552 {
3553 ldef = title = "anonymous enum";
3554 if (isSliceLocal())
3555 {
3556 ldef.prepend("local ");
3557 }
3558 if (lang==SrcLangExt::Cpp)
3559 {
3560 if (isEnumStruct()) ldef.append(" struct");
3561 else if (isStrong()) ldef.append(" class");
3562 }
3563 if (!m_enumBaseType.empty())
3564 {
3565 ldef+=" : "+m_enumBaseType;
3566 }
3567 }
3568 else
3569 {
3570 if (lang==SrcLangExt::Cpp)
3571 {
3572 if (isEnumStruct()) ldef.prepend("struct ");
3573 else if (isStrong()) ldef.prepend("class ");
3574 }
3575 ldef.prepend("enum ");
3576 if (isSliceLocal())
3577 {
3578 ldef.prepend("local ");
3579 }
3580 }
3581 }
3582 else if (isEnumValue())
3583 {
3584 if (ldef.at(0)=='@')
3585 {
3586 ldef=ldef.mid(2);
3587 }
3588 }
3589 else if (isFunction() && !isObjCMethod())
3590 {
3591 title += "()";
3592 }
3593 if (lang == SrcLangExt::Slice)
3594 {
3595 // Remove the container scope from the member name.
3596 DString prefix = scName + sep;
3597 if (size_t pos = ldef.rfind(prefix); pos != DString::npos)
3598 {
3599 ldef.remove(pos, prefix.length());
3600 }
3601 }
3602 ldef.stripPrefix("constexpr ");
3603 ldef.stripPrefix("consteval ");
3604 ldef.stripPrefix("constinit ");
3605 ldef.stripPrefix("static ");
3606
3607 //----------------------------------------
3608
3609 ol.pushGeneratorState();
3610
3611 bool htmlEndLabelTable=false;
3612 StringVector sl = getLabels(scopedContainer);
3613 auto startHtmlLabelTable = [&]()
3614 {
3615 if (!sl.empty())
3616 {
3617 ol.pushGeneratorState();
3618 ol.disableAll();
3620 ol.writeString("<table class=\"mlabels\">\n");
3621 ol.writeString(" <tr>\n");
3622 ol.writeString(" <td class=\"mlabels-left\">\n");
3623 ol.popGeneratorState();
3624 htmlEndLabelTable=true;
3625 }
3626 };
3627
3628 static const reg::Ex r(R"(@\d+)");
3629 reg::Match match;
3630 std::string sdef = ldef.str();
3631 LinkifyTextOptions options;
3632 options.setScope(scopedContainer).setFileScope(getBodyDef()).setSelf(this);
3633 if ((isVariable() || isTypedef()) && reg::search(sdef,match,r))
3634 {
3635 // find enum type and insert it in the definition
3636 bool found=false;
3637 for (const auto &vmd : *ml)
3638 {
3639 if (vmd->isEnumerate() && match.str()==vmd->name())
3640 {
3641 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3642 ol.startMemberDoc(ciname,name(),memAnchor,name(),memCount,memTotal,showInline);
3643 ol.addLabel(cfname, memAnchor);
3644 DString prefix = match.prefix().str();
3645 DString suffix = match.suffix().str();
3647 vmd->writeEnumDeclaration(ol,getClassDef(),getNamespaceDef(),getFileDef(),getGroupDef(),getModuleDef());
3648 linkifyText(TextGeneratorOLImpl(ol),suffix,options);
3649
3650 found=true;
3651 break;
3652 }
3653 }
3654 if (!found) // anonymous compound
3655 {
3656 const ClassDef *annoClassDef=getClassDefOfAnonymousType();
3657 DString typeName;
3658 if (annoClassDef) typeName=annoClassDef->compoundTypeString();
3659 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3660 ol.startMemberDoc(ciname,name(),memAnchor,title,memCount,memTotal,showInline);
3661 ol.addLabel(cfname, memAnchor);
3662 // search for the last anonymous compound name in the definition
3663
3664 startHtmlLabelTable();
3666 if (reg::search(sdef,match,reAnonymous))
3667 {
3668 static const reg::Ex ar(R"([\w@:]*@\d+[\w@:]*)");
3669 reg::Match amatch;
3670 reg::search(sdef,amatch,ar);
3671 DString prefix = amatch.prefix().str();
3672 DString suffix = removeAnonymousScopes(amatch.suffix().str());
3673 //printf("writeDocumentation(): anonymous compound in definition: sdef='%s' prefix='%s' suffix='%s' annoClassDef=%p\n",
3674 // qPrint(sdef), qPrint(prefix),qPrint(suffix),(void*)annoClassDef);
3675 const MemberDef *amd = getAnonymousEnumType();
3676 if (annoClassDef && amd==nullptr)
3677 {
3678 ol.docify(prefix);
3679 DString annTypeName = annoClassDef->displayName(true);
3680 if (suffix.empty())
3681 {
3682 suffix="::"+localName();
3683 }
3684 ol.writeObjectLink(annoClassDef->getReference(),annoClassDef->getOutputFileBase(),
3685 annoClassDef->anchor(),annTypeName);
3686 linkifyText(TextGeneratorOLImpl(ol),suffix,options);
3687 }
3688 else if (amd) // type is an anonymous enum
3689 {
3690 DString typePlaceholder = " { ... } ";
3691 if (lang==SrcLangExt::Cpp)
3692 {
3693 if (amd->isEnumStruct()) typePlaceholder.prepend(" struct");
3694 else if (amd->isStrong()) typePlaceholder.prepend(" class");
3695 }
3696 ol.writeObjectLink(amd->getReference(),amd->getOutputFileBase(),amd->anchor(),prefix+typePlaceholder+suffix);
3697 }
3698 else
3699 {
3700 prefix = match.prefix().str();
3701 suffix = removeAnonymousScopes(match.suffix().str());
3702 ol.docify(prefix);
3703 ol.docify(" ");
3705 //ol.docify(" { ... } ");
3706 linkifyText(TextGeneratorOLImpl(ol),suffix,options);
3707 }
3708 }
3709 else
3710 {
3711 linkifyText(TextGeneratorOLImpl(ol),ldef,options);
3712 }
3713 }
3714 }
3715 else // not an enum value or anonymous compound
3716 {
3717 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3718 ol.startMemberDoc(ciname,name(),memAnchor,title,memCount,memTotal,showInline);
3719 ol.addLabel(cfname, memAnchor);
3720
3721 if (!m_metaData.empty() && getLanguage()==SrcLangExt::Slice)
3722 {
3724 ol.docify(m_metaData);
3726 }
3727
3728 const ClassDef *cd=getClassDef();
3729 const NamespaceDef *nd=getNamespaceDef();
3730 if (!m_defTmpArgLists.empty() && lang==SrcLangExt::Cpp)
3731 // definition has explicit template parameter declarations
3732 {
3733 for (const ArgumentList &tal : m_defTmpArgLists)
3734 {
3735 if (!tal.empty())
3736 {
3738 _writeTemplatePrefix(ol,scopedContainer,tal);
3740 }
3741 }
3742 }
3743 else // definition gets it template parameters from its class
3744 // (since no definition was found)
3745 {
3746 if (cd && lang==SrcLangExt::Cpp && !isTemplateSpecialization())
3747 {
3748 for (const ArgumentList &tal : cd->getTemplateParameterLists())
3749 {
3750 if (!tal.empty())
3751 {
3753 _writeTemplatePrefix(ol,scopedContainer,tal,false);
3755 }
3756 }
3757 }
3758 if (m_tArgList.hasParameters() && lang==SrcLangExt::Cpp) // function template prefix
3759 {
3761 _writeTemplatePrefix(ol,scopedContainer,m_tArgList);
3763 }
3764 }
3765
3766 startHtmlLabelTable();
3767
3769 if (cd && cd->isObjectiveC())
3770 {
3771 // strip scope name
3772 if (size_t ep = ldef.find("::"); ep!=DString::npos)
3773 {
3774 if (size_t sp=ldef.rfind(' ',ep); sp!=DString::npos)
3775 {
3776 ldef=ldef.left(sp+1)+ldef.mid(ep+2);
3777 } else {
3778 ldef=ldef.mid(ep+2);
3779 }
3780 }
3781 // strip keywords
3782 if (size_t dp = ldef.find(':'); dp!=DString::npos)
3783 {
3784 ldef=ldef.left(dp+1);
3785 }
3786 int dl=static_cast<int>(ldef.length());
3787 //printf("start >%s<\n",qPrint(ldef));
3788 int i=dl-1;
3789 while (i>=0 && (isId(ldef.at(i)) || ldef.at(i)==':')) i--;
3790 while (i>=0 && isspace(static_cast<uint8_t>(ldef.at(i)))) i--;
3791 if (i>0)
3792 {
3793 // insert branches around the type
3794 ldef="("+ldef.left(i+1)+")"+ldef.mid(i+1);
3795 }
3796 //printf("end >%s< i=%d\n",qPrint(ldef),i);
3797 if (isStatic()) ldef.prepend("+ "); else ldef.prepend("- ");
3798 }
3799
3800 if (optVhdl)
3801 {
3802 hasParameterList=VhdlDocGen::writeVHDLTypeDocumentation(this,scopedContainer,ol);
3803 }
3804 else if (lang==SrcLangExt::Slice)
3805 {
3806 // Eliminate the self-reference.
3807 size_t pos = ldef.rfind(' ');
3808 if (pos==DString::npos) pos=0;
3809 if (pos>0)
3810 {
3811 linkifyText(TextGeneratorOLImpl(ol),ldef.left(pos),options);
3812 }
3813 ol.docify(ldef.mid(pos));
3814 const Definition *scope = cd;
3815 if (scope==nullptr) scope = nd;
3816 hasParameterList=writeDefArgumentList(ol,scope,this);
3817 }
3818 else
3819 {
3820 linkifyText(TextGeneratorOLImpl(ol),substitute(ldef,"::",sep),options);
3821 const Definition *scope = cd;
3822 if (scope==nullptr) scope = nd;
3823 hasParameterList=writeDefArgumentList(ol,scope,this);
3824 }
3825
3826 if (hasOneLineInitializer()) // add initializer
3827 {
3828 if (isTypeAlias())
3829 {
3830 ol.docify(" = ");
3833 }
3834 else if (!isDefine())
3835 {
3836 ol.docify(" ");
3839 }
3840 else
3841 {
3844 }
3845 }
3846 if (!excpString().empty()) // add exception list
3847 {
3848 writeExceptionList(ol,cd,this);
3849 hasParameterList=true; // call endParameterList below
3850 }
3851 }
3852
3853 ol.pushGeneratorState();
3855 if (!sl.empty())
3856 {
3857 ol.startLabels();
3858 size_t count=0;
3859 for (const auto &s : sl)
3860 {
3861 count++;
3862 ol.writeLabel(s,count==sl.size());
3863 }
3864 ol.endLabels();
3865 }
3866 ol.popGeneratorState();
3867
3868 if (hasParameterList)
3869 {
3870 ol.endParameterList();
3871 ol.endMemberDoc(true);
3872 }
3873 else
3874 {
3875 ol.endMemberDocName();
3876 ol.endMemberDoc(false);
3877 }
3878
3879 // for HTML write the labels here
3880 ol.pushGeneratorState();
3881 ol.disableAll();
3883 if (htmlEndLabelTable)
3884 {
3885 ol.writeString(" </td>\n");
3886 ol.writeString(" <td class=\"mlabels-right\">\n");
3887 ol.startLabels();
3888 size_t count=0;
3889 for (const auto &s : sl)
3890 {
3891 count++;
3892 ol.writeLabel(s,count==sl.size());
3893 }
3894 ol.endLabels();
3895 ol.writeString(" </td>\n");
3896 ol.writeString(" </tr>\n");
3897 ol.writeString("</table>\n");
3898 }
3899 ol.writeString("</div>");
3900 ol.popGeneratorState();
3901
3902
3903 ol.endDoxyAnchor(cfname,memAnchor);
3904 ol.startIndent();
3905
3906 _writeGroupInclude(ol,inGroup);
3907
3908 /* write multi-line initializer (if any) */
3910
3911 /* write brief description */
3912 DString brief = briefDescription();
3913 if (!brief.empty() &&
3914 (Config_getBool(REPEAT_BRIEF) ||
3915 !Config_getBool(BRIEF_MEMBER_DESC)
3916 )
3917 )
3918 {
3919 ol.startParagraph();
3921 briefLine(),
3922 scopedContainer,
3923 this,
3924 brief,
3925 DocOptions()
3926 .setSingleLine(true));
3927 ol.endParagraph();
3928 }
3929
3930 /* write detailed description */
3931 DString detailed = documentation();
3932 if (!detailed.empty() ||
3933 !inbodyDocumentation().empty())
3934 {
3935 // write vhdl inline code with or without option INLINE_SOURCE
3936 if (optVhdl && VhdlDocGen::isMisc(this))
3937 {
3938 VhdlDocGen::writeSource(this,ol,cname);
3939 return;
3940 }
3941 else
3942 {
3943 ol.generateDoc(docFile(),
3944 docLine(),
3945 scopedContainer,
3946 this,
3947 detailed+"\n",
3948 DocOptions()
3949 .setIndexWords(true));
3950 }
3951
3952 if (!inbodyDocumentation().empty())
3953 {
3955 inbodyLine(),
3956 scopedContainer,
3957 this,
3958 inbodyDocumentation()+"\n",
3959 DocOptions()
3960 .setIndexWords(true));
3961 }
3962 }
3963 else if (!brief.empty() && (Config_getBool(REPEAT_BRIEF) || !Config_getBool(BRIEF_MEMBER_DESC)))
3964 {
3965 if (!inbodyDocumentation().empty())
3966 {
3968 inbodyLine(),
3969 scopedContainer,
3970 this,
3971 inbodyDocumentation()+"\n",
3972 DocOptions()
3973 .setIndexWords(true));
3974 }
3975 }
3976
3977
3978 //printf("***** defArgList=%p name=%s docs=%s hasDocs=%d\n",
3979 // defArgList,
3980 // defArgList?defArgList->hasDocumentation():-1);
3981 const ArgumentList &docArgList = m_templateMaster ?
3984 ol.generateDoc(docFile(),
3985 docLine(),
3986 scopedContainer,
3987 this, // memberDef
3988 inlineArgListToDoc(docArgList), // docStr
3989 DocOptions()
3990 .setIndexWords(true));
3991
3992 const ArgumentList &docTemplateArgList = m_templateMaster ?
3994 m_tArgList;
3995 ol.generateDoc(docFile(),
3996 docLine(),
3997 scopedContainer,
3998 this, // memberDef
3999 inlineTemplateArgListToDoc(docTemplateArgList), // docStr
4000 DocOptions()
4001 .setIndexWords(true));
4002
4003 _writeEnumValues(ol,scopedContainer,cfname,ciname,cname);
4007 _writeExamples(ol);
4009 DString scopeStr = getScopeString();
4010 writeSourceDef(ol);
4011 writeInlineCode(ol,scopeStr);
4012 if (hasReferencesRelation()) writeSourceRefs(ol,scopeStr);
4013 if (hasReferencedByRelation()) writeSourceReffedBy(ol,scopeStr);
4014 _writeCallGraph(ol);
4017
4018 ol.endIndent();
4019
4020 // enable LaTeX again
4021 //if (Config_getBool(EXTRACT_ALL) && !hasDocs) ol.enable(OutputType::Latex);
4022 ol.popGeneratorState();
4023
4025}
4026
4027// strip scope and field name from the type
4028// example: "struct N<K::J>::S.v.c" will become "struct v"
4030{
4032 if (ts.endsWith("::")) ts = ts.left(ts.length()-2);
4033 static const reg::Ex re1(R"(\a\w*::)"); // non-template version
4034 static const reg::Ex re2(R"(\a\w*<[^>]*>::)"); // template version
4035 reg::Match match;
4036 std::string t = ts.str();
4037 while (reg::search(t,match,re2) || reg::search(t,match,re1))
4038 {
4039 t = match.prefix().str() + match.suffix().str(); // remove the matched part
4040 }
4041 //printf("simplifyTypeForTable(%s)->%s\n",qPrint(s),qPrint(t));
4042 return t;
4043}
4044
4046{
4047 DString type = m_type;
4048 if (isTypedef() && getLanguage() != SrcLangExt::Slice) type.prepend("typedef ");
4049 return simplifyTypeForTable(type);
4050}
4051
4053{
4054 Definition *scope = getOuterScope();
4055 DString doxyName = name();
4056 DString doxyArgs = argsString();
4057 DString memAnchor = anchor();
4058 DString cfname = getOutputFileBase();
4059 DString cname;
4060 if (scope) cname = scope->name();
4061 if (doxyName.at(0)=='@')
4062 {
4063 doxyName="__unnamed__";
4064 }
4065
4066 LinkifyTextOptions options;
4067 options.setScope(scope).setFileScope(getBodyDef()).setSelf(this);
4068
4069 if (container && container->definitionType()==Definition::TypeClass &&
4070 !(toClassDef(container))->isJavaEnum())
4071 {
4073 ol.startDoxyAnchor(cfname,cname,memAnchor,doxyName,doxyArgs);
4074 ol.addLabel(cfname,memAnchor);
4075
4076 bool written=false;
4077 const ClassDef *annoClassDef=getClassDefOfAnonymousType();
4078 if (annoClassDef)
4079 {
4080 static const reg::Ex ar(R"([\w@:]*@\d+[\w@:]*)"); // anonymous type marker(s) including scope
4081 reg::Match amatch;
4082 std::string stype = m_type.str();
4083 if (reg::search(stype,amatch,ar))
4084 {
4085 size_t ai = amatch.position();
4086 size_t al = amatch.length();
4087 ol.writeObjectLink(annoClassDef->getReference(),annoClassDef->getOutputFileBase(),
4088 annoClassDef->anchor(),m_type.left(ai)+m_type.mid(ai+al));
4089 written=true;
4090 }
4091 }
4092 if (!written)
4093 {
4094 DString ts;
4095 if (isFunctionPtr())
4096 {
4097 ts = m_type + m_args;
4098 }
4099 else
4100 {
4101 ts = fieldType();
4102 }
4103 linkifyText(TextGeneratorOLImpl(ol),ts,options);
4104 }
4105 ol.endDoxyAnchor(cfname,memAnchor);
4107 }
4108
4110 ol.docify(doxyName);
4111 if (isVariable() && !argsString().empty() && !isObjCMethod() && !isFunctionPtr())
4112 {
4114 }
4115 if (!m_bitfields.empty()) // add bitfields
4116 {
4118 }
4119 if (hasOneLineInitializer() && !isDefine())
4120 {
4121 ol.writeString(" ");
4123 }
4125
4127
4128 DString brief = briefDescription();
4129 DString detailed = documentation();
4130
4131 /* write brief description */
4132 if (!brief.empty())
4133 {
4135 briefLine(),
4136 getOuterScope()?getOuterScope():container,this,
4137 brief,
4138 DocOptions()
4139 .setSingleLine(true));
4140 }
4141
4142 /* write detailed description */
4143 if (!detailed.empty())
4144 {
4145 if (!brief.empty())
4146 {
4148 ol.lineBreak();
4150 }
4151 ol.generateDoc(docFile(),
4152 docLine(),
4153 getOuterScope()?getOuterScope():container,this,
4154 detailed+"\n",
4155 DocOptions());
4156 }
4157
4158 ol.endInlineMemberDoc();
4159}
4160
4162{
4163 if (m_mtype == MemberType::Define)
4164 {
4165 return "macro definition";
4166 }
4167 else if (m_mtype == MemberType::Enumeration)
4168 {
4169 return "enumeration";
4170 }
4171 return to_string_lower(m_mtype);
4172}
4173
4175{
4176 /*
4177 * Removed bug_303020:
4178 * if (m_memberGroup) return;
4179 */
4180 const ClassDef *cd = getClassDef();
4181 const NamespaceDef *nd = getNamespaceDef();
4182 const FileDef *fd = getFileDef();
4183 const GroupDef *gd = getGroupDef();
4184 const Definition *d=nullptr;
4185 DString t;
4186 if (cd)
4187 {
4188 t=cd->compoundTypeString();
4189 d=cd;
4190 }
4191 else if (nd)
4192 {
4193 t=nd->compoundTypeString();
4194 d=nd;
4195 }
4196 else if (gd)
4197 {
4198 t="group";
4199 d=gd;
4200 }
4201 else
4202 {
4203 t="file";
4204 d=fd;
4205 }
4206 bool extractAll = Config_getBool(EXTRACT_ALL);
4207
4208 //printf("%s:warnIfUndoc: hasUserDocs=%d isFriendClass=%d protection=%d isRef=%d isDel=%d\n",
4209 // qPrint(name()),
4210 // hasUserDocumentation(),isFriendClass(),protectionLevelVisible(m_prot),isReference(),isDeleted());
4211 if ((!hasUserDocumentation() && !extractAll) &&
4212 !isFriendClass() &&
4213 name().find('@')==DString::npos && d && d->name().find('@')==DString::npos &&
4216 !isReference() && !isDeleted()
4217 )
4218 {
4219 SrcLangExt lang = getLanguage();
4220 DString sep = getLanguageSpecificSeparator(lang,true);
4221 warn_undoc(getDefFileName(),getDefLine(),"Member {}{} ({}) of {} {} is not documented.",
4223 substitute(d->name(),"::",sep));
4224 }
4225 else if (!hasDetailedDescription())
4226 {
4228 }
4229
4230 // if it is an enum, we check that its members are documented
4231 if (!extractAll && isEnumerate() && Config_getBool(WARN_IF_UNDOC_ENUM_VAL))
4232 {
4233 for (const auto &fmd : enumFieldList())
4234 {
4235 if (!fmd->isLinkableInProject())
4236 {
4237 SrcLangExt lang = getLanguage();
4238 DString sep = getLanguageSpecificSeparator(lang,true);
4239 warn(fmd->getDefFileName(),fmd->getDefLine(), "Documentation for enum member '{}{}{}' is missing.",
4240 qualifiedName(),sep,fmd->name());
4241 }
4242 }
4243 }
4244}
4245
4247{
4248 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
4249 bool extractStatic = Config_getBool(EXTRACT_STATIC);
4250 return (!isAnonymous() &&
4251 (!hideUndocMembers || hasDocumentation()) &&
4252 (!isStatic() || extractStatic) &&
4253 isLinkable()
4254 );
4255}
4256
4257static DString stripTrailingReturn(const DString &trailRet)
4258{
4259 DString ret = trailRet;
4260
4261 ret = ret.stripWhiteSpace();
4262 if (ret.startsWith("->"))
4263 {
4264 ret = ret.mid(2).stripWhiteSpace();
4265 return ret;
4266 }
4267 return trailRet;
4268}
4269
4271
4272void MemberDefImpl::detectUndocumentedParams(bool hasParamCommand,bool hasReturnCommand) const
4273{
4274 //printf("%s:detectUndocumentedParams(%d,%d)\n",qPrint(name()),hasParamCommand,hasReturnCommand);
4275 bool isPython = getLanguage()==SrcLangExt::Python;
4276
4277 // this function is called while parsing the documentation. A member can have multiple
4278 // documentation blocks, which could be handled by multiple threads, hence this guard.
4279 std::lock_guard<std::mutex> lock(g_detectUndocumentedParamsMutex);
4280
4282 {
4283 //printf("%s:hasDocumentedParams=true;\n",qPrint(name()));
4284 m_hasDocumentedParams = true;
4285 }
4286 else if (!m_hasDocumentedParams)
4287 {
4288 const ArgumentList &al = argumentList();
4289 const ArgumentList &declAl = declArgumentList();
4290 bool allDoc=true; // no parameter => all parameters are documented
4291 if ( // member has parameters
4292 al.hasParameters() // with at least one parameter (that is not void)
4293 )
4294 {
4295 // see if all parameters have documentation
4296 for (auto it = al.begin(); it!=al.end() && allDoc; ++it)
4297 {
4298 const Argument &a = *it;
4299 if (!a.name.empty() && a.type!="void" && a.name!="..." &&
4300 !(isPython && (a.name=="self" || a.name=="cls"))
4301 )
4302 {
4303 allDoc = !a.docs.empty();
4304 }
4305 //printf("a.type=%s a.name=%s doc=%s\n",
4306 // qPrint(a.type),qPrint(a.name),qPrint(a.docs));
4307 }
4308 if (!allDoc && declAl.empty()) // try declaration arguments as well
4309 {
4310 allDoc=true;
4311 for (auto it = al.begin(); it!=al.end() && allDoc; ++it)
4312 {
4313 const Argument &a = *it;
4314 if (!a.name.empty() && a.type!="void" && a.name!="..." &&
4315 !(isPython && (a.name=="self" || a.name=="cls"))
4316 )
4317 {
4318 allDoc = !a.docs.empty();
4319 }
4320 //printf("a.name=%s doc=%s\n",qPrint(a.name),qPrint(a.docs));
4321 }
4322 }
4323 }
4324 if (allDoc)
4325 {
4326 //printf("%s:hasDocumentedParams=true;\n",qPrint(name()));
4327 m_hasDocumentedParams = true;
4328 }
4329 }
4330
4331 //printf("Member %s hasDocumentedReturnType=%d hasReturnCommand=%d\n",
4332 // qPrint(name()),m_hasDocumentedReturnType,hasReturnCommand);
4334}
4335
4337{
4338 DString returnType = typeString();
4339 bool isFortran = getLanguage()==SrcLangExt::Fortran;
4340 bool isFortranSubroutine = isFortran && returnType.find("subroutine")!=DString::npos;
4341
4342 bool isVoidReturn = returnType=="void" || returnType.endsWith(" void");
4343 if (!isVoidReturn && (returnType=="auto" || returnType.endsWith(" auto")))
4344 {
4346 if (!defArgList.trailingReturnType().empty())
4347 {
4348 DString strippedTrailingReturn = stripTrailingReturn(defArgList.trailingReturnType());
4349 isVoidReturn = (strippedTrailingReturn=="void") || (strippedTrailingReturn.endsWith(" void"));
4350 }
4351 }
4352 if (!Config_getBool(EXTRACT_ALL) &&
4353 Config_getBool(WARN_IF_UNDOCUMENTED) &&
4354 Config_getBool(WARN_NO_PARAMDOC) &&
4355 isFunction() &&
4356 !isDeleted() &&
4357 !isReference() &&
4359 {
4361 {
4363 "parameters of member {} are not documented",
4364 qualifiedName());
4365 }
4367 hasDocumentation() && !returnType.empty() &&
4368 !( // not one of the cases where nothing is returned
4369 isVoidReturn || // void return type
4370 isFortranSubroutine || // fortran subroutine
4371 isConstructor() || // a constructor
4372 isDestructor() || // or a destructor
4373 isFriend() // or a friend
4374 )
4375 )
4376 {
4378 "return type of member {} is not documented",
4379 qualifiedName());
4380 }
4381 }
4382 if (Config_getBool(WARN_IF_DOC_ERROR) &&
4384 (isVoidReturn || // void return type
4385 isFortranSubroutine || // fortran subroutine
4386 isConstructor() || // a constructor
4387 isDestructor())) // or destructor
4388 {
4389 warn_doc_error(docFile(),docLine(),"found documented return type for {} that does not return anything",
4390 qualifiedName());
4391 }
4392}
4393
4395{
4396 ClassDef *fcd=nullptr;
4397 DString baseName=name();
4398 if (size_t i=baseName.find('<'); i!=DString::npos) baseName=baseName.left(i);
4399 return (isFriendClass() &&
4400 (fcd=getClass(baseName)) && fcd->isLinkable());
4401}
4402
4404{
4405 return m_defArgList.isDeleted();
4406}
4407
4409{
4411 (m_mtype==MemberType::Enumeration && m_docEnumValues) || // has enum values
4412 (m_defArgList.hasDocumentation()|| m_tArgList.hasTemplateDocumentation()); // has doc (template) arguments
4413}
4414
4415
4420
4422{
4423 DString result;
4424 if (isStrong()) result=name();
4425 else if (getClassDef()) result=getClassDef()->displayName();
4426 else if (getNamespaceDef()) result=getNamespaceDef()->displayName();
4427 return result;
4428}
4429
4431{
4432 DString memAnchor = name();
4433 if (!m_args.empty()) memAnchor+=m_args;
4434 if (m_memSpec.isAlias()) // this is for backward compatibility
4435 {
4436 memAnchor.prepend(" = "+m_initializer);
4437 }
4438 memAnchor.prepend(definition()); // actually the method name is now included
4439 // twice, which is silly, but we keep it this way for backward
4440 // compatibility.
4441
4442 // include number of template arguments as well,
4443 // to distinguish between two template
4444 // specializations that only differ in the template parameters.
4446 {
4447 char buf[20];
4448 snprintf(buf,20,"%d:",static_cast<int>(m_tArgList.size()));
4449 buf[19]='\0';
4450 memAnchor.prepend(buf);
4451 }
4452 if (!m_requiresClause.empty())
4453 {
4454 memAnchor+=" "+m_requiresClause;
4455 }
4456 if (m_redefineCount>0)
4457 {
4458 char buf[20];
4459 snprintf(buf,20,":%d",m_redefineCount);
4460 buf[19]='\0';
4461 memAnchor.append(buf);
4462 }
4463
4464 // convert to md5 hash
4465 m_anc = "a"+md5str(memAnchor.view());
4466}
4467
4469 const DString &fileName,int startLine,
4470 bool hasDocs,MemberDef *member)
4471{
4472 //printf("%s MemberDefImpl::setGroupDef(%s)\n",qPrint(name()),qPrint(gd->name()));
4473 m_group=gd;
4474 m_grouppri=pri;
4475 m_groupFileName=fileName;
4476 m_groupStartLine=startLine;
4477 m_groupHasDocs=hasDocs;
4478 m_groupMember=member;
4480}
4481
4496
4504
4506{
4507 m_nspace=nd;
4508 setOuterScope(nd);
4509}
4510
4512 const ArgumentList &formalArgs,const std::unique_ptr<ArgumentList> &actualArgs) const
4513{
4514 //printf(" Member %s %s %s\n",qPrint(typeString()),qPrint(name()),qPrint(argsString()));
4515 std::unique_ptr<ArgumentList> actualArgList = std::make_unique<ArgumentList>(m_defArgList);
4516 if (!m_defArgList.empty())
4517 {
4518 // replace formal arguments with actuals
4519 for (Argument &arg : *actualArgList)
4520 {
4521 arg.type = substituteTemplateArgumentsInString(arg.type,formalArgs,actualArgs.get());
4522 }
4523 actualArgList->setTrailingReturnType(
4524 substituteTemplateArgumentsInString(actualArgList->trailingReturnType(),formalArgs,actualArgs.get()));
4525 }
4526
4527 DString methodName=name();
4528 if (methodName.startsWith("operator ")) // conversion operator
4529 {
4530 methodName=substituteTemplateArgumentsInString(methodName,formalArgs,actualArgs.get());
4531 }
4532
4533 auto imd = createMemberDef(
4535 substituteTemplateArgumentsInString(m_type,formalArgs,actualArgs.get()),
4536 methodName,
4537 substituteTemplateArgumentsInString(m_args,formalArgs,actualArgs.get()),
4540 ArgumentList(), ArgumentList(), ""
4541 );
4542 auto mmd = toMemberDefMutable(imd.get());
4543 mmd->moveArgumentList(std::move(actualArgList));
4544 mmd->setDefinition(substituteTemplateArgumentsInString(m_def,formalArgs,actualArgs.get()));
4545 mmd->setBodyDef(getBodyDef());
4546 mmd->setBodySegment(getDefLine(),getStartBodyLine(),getEndBodyLine());
4547 mmd->setFormalTemplateArguments(formalArgs);
4548
4549 // TODO: init other member variables (if needed).
4550 // TODO: reimplemented info
4551 return imd;
4552}
4553
4555{
4556 //printf("%s: init=%s, initLines=%d maxInitLines=%d userInitLines=%d\n",
4557 // qPrint(name()),qPrint(m_initializer),m_initLines,
4558 // m_maxInitLines,m_userInitLines);
4559 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4560 return !m_initializer.empty() && m_initLines==0 && // one line initializer
4561 !isFuncLikeMacro &&
4562 ((m_maxInitLines>0 && m_userInitLines==-1) || m_userInitLines>0); // enabled by default or explicitly
4563}
4564
4566{
4567 //printf("initLines=%d userInitLines=%d maxInitLines=%d\n",
4568 // initLines,userInitLines,maxInitLines);
4569 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4570 return (m_initLines>0 || (!m_initializer.empty() && isFuncLikeMacro)) &&
4571 ((m_initLines<m_maxInitLines && m_userInitLines==-1) // implicitly enabled
4572 || m_initLines<m_userInitLines // explicitly enabled
4573 );
4574}
4575
4577{
4578 size_t indent=0;
4580 int l=static_cast<int>(m_initializer.length());
4581 int p=l-1;
4582 while (p>=0 && isspace(static_cast<uint8_t>(m_initializer.at(p)))) p--;
4586
4587 //printf("%s::setInitializer(%s)\n",qPrint(name()),qPrint(m_initializer));
4588}
4589
4591{
4592 bool optimizeOutputForC = Config_getBool(OPTIMIZE_OUTPUT_FOR_C);
4593 SrcLangExt lang = getLanguage();
4594 if (!isLinkableInProject()) return;
4595 DString memLabel;
4596 if (optimizeOutputForC)
4597 {
4598 memLabel=theTranslator->trGlobal(true,true);
4599 }
4600 else if (lang==SrcLangExt::Fortran)
4601 {
4602 memLabel=theTranslator->trSubprogram(true,true);
4603 }
4604 else
4605 {
4606 memLabel=theTranslator->trMember(true,true);
4607 }
4608 DString memName = name();
4611 (toClassDef(pd))->displayName() : pd->name();
4612 DString sep = getLanguageSpecificSeparator(lang,true);
4613 DString memArgs;
4614 if (!isRelated())
4615 {
4616 if (isObjCMethod())
4617 {
4618 memName = "[" + pd->name() + " " + name() + "]";
4619 }
4620 else
4621 {
4622 if (pd!=Doxygen::globalScope) memName.prepend(pdName+sep);
4623 memArgs = argsString();
4624 }
4625 }
4626 const RefItemVector &xrefItems = xrefListItems();
4627 if (sep!="::")
4628 {
4629 memName = substitute(memName,"::",sep);
4630 }
4631 addRefItem(xrefItems,
4632 qualifiedName()+argsString(), // argsString is needed for overloaded functions (see bug 609624)
4633 memLabel,
4634 getOutputFileBase()+"#"+anchor(),memName,memArgs,pd);
4635}
4636
4641
4643{
4644 auto it = m_sectionMap.find(container);
4645 return it!=m_sectionMap.end() ? it->second : nullptr;
4646}
4647
4649{
4650 //printf("MemberDefImpl::setSectionList(%s,%p) name=%s\n",qPrint(d->name()),sl,qPrint(name()));
4651 m_sectionMap.emplace(container,sl);
4652}
4653
4655{
4656 if (count>25)
4657 {
4659 "Internal inconsistency: recursion detected in overload relation for member {}!",name());
4660 return Specifier::Normal;
4661 }
4662 Specifier v = m_virt;
4663 const MemberDef *rmd = reimplements();
4664 while (rmd && v==Specifier::Normal)
4665 {
4666 v = rmd->virtualness(count+1)==Specifier::Normal ? Specifier::Normal : Specifier::Virtual;
4667 rmd = rmd->reimplements();
4668 }
4669 return v;
4670}
4671
4672void MemberDefImpl::writeTagFile(TextStream &tagFile,bool useQualifiedName,bool showNamespaceMembers) const
4673{
4674 if (!isLinkableInProject()) return;
4675 if (!showNamespaceMembers && getNamespaceDef()) return;
4676 tagFile << " <member kind=\"";
4677 if (m_mtype == MemberType::Enumeration)
4678 {
4679 tagFile << "enumeration";
4680 }
4681 else
4682 {
4683 tagFile << to_string_lower(m_mtype);
4684 }
4685 if (m_prot!=Protection::Public)
4686 {
4687 tagFile << "\" protection=\"";
4688 if (m_prot==Protection::Protected) tagFile << "protected";
4689 else if (m_prot==Protection::Package) tagFile << "package";
4690 else /* Private */ tagFile << "private";
4691 }
4692 if (m_virt!=Specifier::Normal)
4693 {
4694 tagFile << "\" virtualness=\"";
4695 if (m_virt==Specifier::Virtual) tagFile << "virtual";
4696 else /* Pure */ tagFile << "pure";
4697 }
4698 if (isStatic())
4699 {
4700 tagFile << "\" static=\"yes";
4701 }
4702 tagFile << "\">\n";
4703 if (typeString()!=DString("@"))
4704 {
4705 tagFile << " <type>" << convertToXML(typeString()) << "</type>\n";
4706 }
4709 tagFile << " <name>" << convertToXML(useQualifiedName ? qualifiedName() : name()) << "</name>\n";
4710 tagFile << " <anchorfile>" << convertToXML(fn) << "</anchorfile>\n";
4711 tagFile << " <anchor>" << convertToXML(anchor()) << "</anchor>\n";
4712 DString idStr = id();
4713 if (!idStr.empty())
4714 {
4715 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
4716 }
4717 tagFile << " <arglist>" << convertToXML(argsString()) << "</arglist>\n";
4718 if (isStrong())
4719 {
4720 for (const auto &fmd : m_enumFields)
4721 {
4722 if (!fmd->isReference())
4723 {
4724 tagFile << " <enumvalue file=\"" << convertToXML(fn);
4725 tagFile << "\" anchor=\"" << convertToXML(fmd->anchor());
4726 idStr = fmd->id();
4727 if (!idStr.empty())
4728 {
4729 tagFile << "\" clangid=\"" << convertToXML(idStr);
4730 }
4731 tagFile << "\">" << convertToXML(fmd->name()) << "</enumvalue>\n";
4732 }
4733 }
4734 }
4735 writeDocAnchorsToTagFile(tagFile);
4736 tagFile << " </member>\n";
4737}
4738
4740{
4741 m_isConstructorCached=1; // false
4742 if (getClassDef())
4743 {
4744 if (m_isDMember) // for D
4745 {
4746 m_isConstructorCached = name()=="this" ? 2 : 1;
4747 return;
4748 }
4749 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4750 {
4751 m_isConstructorCached = name()=="__construct" ? 2 : 1;
4752 return;
4753 }
4754 else if (name()=="__init__" &&
4755 getLanguage()==SrcLangExt::Python) // for Python
4756 {
4757 m_isConstructorCached = 2; // true
4758 return;
4759 }
4760 else // for other languages
4761 {
4762 DString locName = getClassDef()->localName();
4763 size_t i=locName.find('<');
4764 if (i==DString::npos) // not a template class
4765 {
4766 m_isConstructorCached = name()==locName ? 2 : 1;
4767 }
4768 else
4769 {
4770 m_isConstructorCached = name()==locName.left(i) ? 2 : 1;
4771 }
4772 return;
4773 }
4774 }
4775}
4776
4778{
4779 if (m_isConstructorCached==0)
4780 {
4781 MemberDefImpl *that = const_cast<MemberDefImpl*>(this);
4782 that->_computeIsConstructor();
4783 }
4785 return m_isConstructorCached==2;
4786
4787}
4788
4790{
4791 bool isDestructor = false;
4792 if (m_isDMember) // for D
4793 {
4794 isDestructor = name()=="~this";
4795 }
4796 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4797 {
4798 isDestructor = name()=="__destruct";
4799 }
4800 else if (name()=="__del__" &&
4801 getLanguage()==SrcLangExt::Python) // for Python
4802 {
4803 isDestructor = true;
4804 }
4805 else if (getLanguage()==SrcLangExt::Fortran) // for Fortran
4806 {
4807 isDestructor = typeString()=="final";
4808 }
4809 else // other languages
4810 {
4811 isDestructor =
4812 (name().find('~')!=DString::npos || name().find('!')!=DString::npos) // The ! is for C++/CLI
4813 && name().find("operator")==DString::npos;
4814 }
4816}
4817
4819{
4820 if (m_isDestructorCached==0)
4821 {
4822 MemberDefImpl *that=const_cast<MemberDefImpl*>(this);
4823 that->_computeIsDestructor();
4824 }
4826 return m_isDestructorCached==2;
4827}
4828
4830 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const
4831{
4832 int enumMemCount=0;
4833
4834 uint32_t numVisibleEnumValues=0;
4835 for (const auto &fmd : m_enumFields)
4836 {
4837 if (fmd->isBriefSectionVisible()) numVisibleEnumValues++;
4838 }
4839 if (numVisibleEnumValues==0 && !isBriefSectionVisible())
4840 {
4841 return;
4842 }
4843
4844 DString n = name();
4845 if (size_t i=n.rfind("::"); i!=DString::npos) n=n.mid(i+2); // strip scope (TODO: is this needed?)
4846 if (n[0]!='@') // not an anonymous enum
4847 {
4849 {
4850 //_writeTagData(compoundType);
4851 writeLink(typeDecl,cd,nd,fd,gd,mod);
4852 }
4853 else
4854 {
4855 typeDecl.startBold();
4856 typeDecl.docify(n);
4857 typeDecl.endBold();
4858 }
4859 typeDecl.writeChar(' ');
4860 }
4861 if (!m_enumBaseType.empty())
4862 {
4863 typeDecl.writeChar(':');
4864 typeDecl.writeChar(' ');
4865 typeDecl.docify(m_enumBaseType);
4866 typeDecl.writeChar(' ');
4867 }
4868
4869 uint32_t enumValuesPerLine = static_cast<uint32_t>(Config_getInt(ENUM_VALUES_PER_LINE));
4870 if (numVisibleEnumValues>0 && enumValuesPerLine>0)
4871 {
4872 typeDecl.docify("{ ");
4873
4874 auto it = m_enumFields.begin();
4875 if (it!=m_enumFields.end())
4876 {
4877 const MemberDef *fmd=*it;
4878 bool fmdVisible = fmd->isBriefSectionVisible();
4879 bool first=true;
4880 while (fmd)
4881 {
4882 if (fmdVisible)
4883 {
4884 if (!first)
4885 {
4886 typeDecl.writeString(", ");
4887 }
4888 /* in html we start a new line after a number of items */
4889 if (numVisibleEnumValues>enumValuesPerLine
4890 && (enumMemCount%enumValuesPerLine)==0
4891 )
4892 {
4893 typeDecl.pushGeneratorState();
4895 typeDecl.enable(OutputType::Latex);
4896 typeDecl.enable(OutputType::Docbook);
4897 typeDecl.lineBreak();
4898 typeDecl.disable(OutputType::Latex);
4899 typeDecl.disable(OutputType::Docbook);
4900 typeDecl.writeString("&#160;&#160;");
4901 typeDecl.popGeneratorState();
4902 }
4903
4904 if (fmd->hasDocumentation()) // enum value has docs
4905 {
4906 fmd->writeLink(typeDecl,cd,nd,fd,gd,mod);
4907 }
4908 else // no docs for this enum value
4909 {
4910 typeDecl.startBold();
4911 typeDecl.docify(fmd->name());
4912 typeDecl.endBold();
4913 }
4914 if (fmd->hasOneLineInitializer()) // enum value has initializer
4915 {
4916 //typeDecl.writeString(" = ");
4917 typeDecl.writeString(" ");
4918 typeDecl.parseText(fmd->initializer());
4919 }
4920 first=false;
4921 }
4922
4923 bool prevVisible = fmdVisible;
4924 ++it;
4925 if (it!=m_enumFields.end())
4926 {
4927 fmd=*it;
4928 }
4929 else
4930 {
4931 fmd=nullptr;
4932 }
4933 if (prevVisible)
4934 {
4935 typeDecl.disable(OutputType::Man);
4936 typeDecl.writeString("\n"); // to prevent too long lines in LaTeX
4937 typeDecl.enable(OutputType::Man);
4938 enumMemCount++;
4939 }
4940 }
4941 if (numVisibleEnumValues>enumValuesPerLine)
4942 {
4943 typeDecl.pushGeneratorState();
4945 typeDecl.lineBreak();
4946 typeDecl.popGeneratorState();
4947 }
4948 }
4949 typeDecl.docify(" }");
4950 }
4951}
4952
4953void MemberDefImpl::moveArgumentList(std::unique_ptr<ArgumentList> al)
4954{
4955 m_defArgList = *al;
4956}
4957
4958void MemberDefImpl::moveDeclArgumentList(std::unique_ptr<ArgumentList> al)
4959{
4960 m_declArgList = *al;
4961}
4962
4967
4969{
4970 m_type = t;
4971}
4972
4979
4981{
4983 if (e) Doxygen::parseSourcesNeeded = true;
4984}
4985
4987{
4989 if (e) Doxygen::parseSourcesNeeded = true;
4990}
4991
4997
5003
5008
5013
5015{
5016 if (getClassDef() && getClassDef()->isObjectiveC() && isFunction()) return true;
5017 return false;
5018}
5019
5021{
5022 if (getClassDef() && getClassDef()->isObjectiveC() && isProperty()) return true;
5023 return false;
5024}
5025
5027{
5028 if (getClassDef() && getClassDef()->isCSharp() && isProperty()) return true;
5029 return false;
5030}
5031
5033{
5034 if (isObjCMethod())
5035 {
5036 DString qm;
5037 if (isStatic()) qm="+"; else qm="-";
5038 qm+="[";
5039 qm+=getClassDef()->name()+" ";
5040 qm+=name();
5041 qm+="]";
5042 return qm;
5043 }
5044 else if (m_enumScope && m_enumScope->isStrong())
5045 {
5046 return m_enumScope->qualifiedName()+
5048 localName();
5049 }
5050 else
5051 {
5053 }
5054}
5055
5057{
5058 if (ti)
5059 {
5060 //printf("%s: Setting tag name=%s anchor=%s\n",qPrint(name()),qPrint(ti->tagName),qPrint(ti->anchor));
5061 m_anc=ti->anchor;
5062 setReference(ti->tagName);
5064 }
5065}
5066
5067DString MemberDefImpl::objCMethodName(bool localLink,bool showStatic) const
5068{
5069 DString qm;
5070 if (showStatic)
5071 {
5072 if (isStatic()) qm="+ "; else qm="- ";
5073 }
5074 qm+=name();
5075 if (!localLink) // link to method of same class
5076 {
5077 qm+=" (";
5078 qm+=getClassDef()->name();
5079 qm+=")";
5080 }
5081 return qm;
5082}
5083
5085{
5086 return m_decl;
5087}
5088
5090{
5091 return m_def;
5092}
5093
5098
5100{
5101 return m_type;
5102}
5103
5105{
5106 return m_args;
5107}
5108
5110{
5111 return m_exception;
5112}
5113
5115{
5116 return m_bitfields;
5117}
5118
5120{
5121 return m_initializer;
5122}
5123
5125{
5126 return m_initLines;
5127}
5128
5130{
5131 return m_docTransferDone;
5132}
5133
5138
5143
5145{
5146 return m_classDef;
5147}
5148
5153
5158
5160{
5161 return m_fileDef;
5162}
5163
5165{
5166 return m_fileDef;
5167}
5168
5170{
5171 return m_nspace;
5172}
5173
5178
5180{
5181 return m_read;
5182}
5183
5185{
5186 return m_write;
5187}
5188
5190{
5191 return m_group;
5192}
5193
5195{
5196 return m_group;
5197}
5198
5200{
5201 return m_moduleDef;
5202}
5203
5208
5213
5215{
5216 return m_groupStartLine;
5217}
5218
5220{
5221 return m_groupHasDocs;
5222}
5223
5225{
5226 return m_prot;
5227}
5228
5230{
5231 return m_mtype;
5232}
5233
5235{
5236 return m_mtype==MemberType::Signal;
5237}
5238
5240{
5241 return m_mtype==MemberType::Slot;
5242}
5243
5245{
5246 return m_mtype==MemberType::Variable;
5247}
5248
5250{
5251 return m_mtype==MemberType::Enumeration;
5252}
5253
5255{
5256 return m_mtype==MemberType::EnumValue;
5257}
5258
5260{
5261 return m_mtype==MemberType::Typedef;
5262}
5263
5265{
5266 return m_mtype==MemberType::Sequence;
5267}
5268
5270{
5271 return m_mtype==MemberType::Dictionary;
5272}
5273
5275{
5276 return m_mtype==MemberType::Function;
5277}
5278
5280{
5281 return m_mtype==MemberType::Variable &&
5283}
5284
5286{
5287 return m_mtype==MemberType::Define;
5288}
5289
5291{
5292 return m_mtype==MemberType::Friend;
5293}
5294
5296{
5297 return m_mtype==MemberType::DCOP;
5298}
5299
5301{
5302 return m_mtype==MemberType::Property;
5303}
5304
5306{
5307 return m_mtype==MemberType::Event;
5308}
5309
5311{
5312 return m_related == Relationship::Related;
5313}
5314
5316{
5317 return m_related == Relationship::Foreign;
5318}
5319
5321{
5322 return m_stat;
5323}
5324
5326{
5327 return m_memSpec.isInline();
5328}
5329
5331{
5332 return m_memSpec.isExplicit();
5333}
5334
5336{
5337 return m_memSpec.isMutable();
5338}
5339
5341{
5342 return m_memSpec.isThreadLocal();
5343}
5344
5346{
5347 return m_memSpec.isGettable();
5348}
5349
5351{
5352 return m_memSpec.isPrivateGettable();
5353}
5354
5356{
5357 return m_memSpec.isProtectedGettable();
5358}
5359
5361{
5362 return m_memSpec.isSettable();
5363}
5364
5366{
5367 return m_memSpec.isPrivateSettable();
5368}
5369
5371{
5372 return m_memSpec.isProtectedSettable();
5373}
5374
5376{
5377 return m_memSpec.isAddable();
5378}
5379
5381{
5382 return m_memSpec.isRemovable();
5383}
5384
5386{
5387 return m_memSpec.isRaisable();
5388}
5389
5391{
5392 return m_memSpec.isReadable();
5393}
5394
5396{
5397 return m_memSpec.isWritable();
5398}
5399
5401{
5402 return m_memSpec.isFinal();
5403}
5404
5406{
5407 return m_memSpec.isNew();
5408}
5409
5411{
5412 return m_memSpec.isSealed();
5413}
5414
5416{
5417 return m_memSpec.isOverride();
5418}
5419
5421{
5422 return m_memSpec.isInitonly();
5423}
5424
5426{
5427 return m_memSpec.isAbstract();
5428}
5429
5431{
5432 return m_memSpec.isOptional();
5433}
5434
5436{
5437 return m_memSpec.isRequired();
5438}
5439
5441{
5442 return m_memSpec.isNonAtomic();
5443}
5444
5446{
5447 return m_memSpec.isCopy();
5448}
5449
5451{
5452 return m_memSpec.isAssign();
5453}
5454
5456{
5457 return m_memSpec.isRetain();
5458}
5459
5461{
5462 return m_memSpec.isWeak();
5463}
5464
5466{
5467 return m_memSpec.isStrong();
5468}
5469
5471{
5472 return m_memSpec.isEnumStruct();
5473}
5474
5476{
5477 return m_mtype==MemberType::EnumValue &&
5478 m_enumScope &&
5480}
5481
5483{
5484 return m_memSpec.isUnretained();
5485}
5486
5488{
5489 return m_memSpec.isAlias();
5490}
5491
5493{
5494 return m_memSpec.isDefault();
5495}
5496
5498{
5499 return m_memSpec.isDelete();
5500}
5501
5503{
5504 return m_memSpec.isNoExcept();
5505}
5506
5508{
5509 return m_memSpec.isAttribute();
5510}
5511
5513{
5514 return m_memSpec.isProperty();
5515}
5516
5518{
5519 return m_memSpec.isReadonly();
5520}
5521
5523{
5524 return m_memSpec.isBound();
5525}
5526
5528{
5529 return m_memSpec.isConstrained();
5530}
5531
5533{
5534 return m_memSpec.isTransient();
5535}
5536
5538{
5539 return m_memSpec.isMaybeVoid();
5540}
5541
5543{
5544 return m_memSpec.isMaybeDefault();
5545}
5546
5548{
5549 return m_memSpec.isMaybeAmbiguous();
5550}
5551
5553{
5554 return m_memSpec.isPublished();
5555}
5556
5557
5559{
5560 return m_implOnly;
5561}
5562
5564{
5565 return m_explExt;
5566}
5567
5569{
5570 return m_tspec;
5571}
5572
5574{
5575 return isFunction() ||
5576 isSlot() ||
5577 isSignal() ||
5578 isConstructor() ||
5579 isDestructor() ||
5580 isObjCMethod() ||
5581 isFriend();
5582}
5583
5585{
5586 return m_relatedAlso;
5587}
5588
5590{
5591 return m_docEnumValues;
5592}
5593
5595{
5596 return m_annEnumType;
5597}
5598
5603
5608
5610{
5611 return m_docsForDefinition;
5612}
5613
5615{
5616 return m_enumScope;
5617}
5618
5620{
5621 return m_livesInsideEnum;
5622}
5623
5625{
5626 return m_memSpec.isLocal();
5627}
5628
5630{
5631 return m_memSpec.isNoDiscard();
5632}
5633
5635{
5636 return m_memSpec.isConstExpr();
5637}
5638
5640{
5641 return m_memSpec.isConstEval();
5642}
5643
5645{
5646 return m_memSpec.isConstInit();
5647}
5648
5650{
5651 return m_enumFields;
5652}
5653
5655{
5656 return m_examples;
5657}
5658
5660{
5661 return m_proto;
5662}
5663
5665{
5666 return m_defArgList;
5667}
5668
5670{
5671 return m_declArgList;
5672}
5673
5675{
5676 ArgumentList &decAl = m_declArgList;
5677 ArgumentList &defAl = m_defArgList;
5678 const ArgumentList &decAlSrc = md->declArgumentList();
5679 const ArgumentList &defAlSrc = md->argumentList();
5680 auto decSrc = decAlSrc.begin(), defSrc = defAlSrc.begin();
5681 for (auto decIt = decAl.begin(), defIt = defAl.begin();
5682 decIt != decAl.end() && defIt != defAl.end() && decSrc != decAlSrc.end() && defSrc != defAlSrc.end();
5683 ++decIt, ++defIt, ++decSrc, ++defSrc++)
5684 {
5685 Argument &decA = *decIt;
5686 Argument &defA = *defIt;
5687 const Argument &decAS = *decSrc;
5688 const Argument &defAS = *defSrc;
5689 if (decA.name.empty())
5690 {
5691 if (!defA.name.empty())
5692 {
5693 decA.name = defA.name;
5694 }
5695 else if (!decAS.name.empty())
5696 {
5697 decA.name = decAS.name;
5698 }
5699 else if (!defAS.name.empty())
5700 {
5701 decA.name = defAS.name;
5702 }
5703 }
5704 if (defA.name.empty())
5705 {
5706 if (!decA.name.empty())
5707 {
5708 defA.name = decA.name;
5709 }
5710 else if (!decAS.name.empty())
5711 {
5712 defA.name = decAS.name;
5713 }
5714 else if (!defAS.name.empty())
5715 {
5716 defA.name = defAS.name;
5717 }
5718 }
5719 }
5720}
5721
5723{
5724 return m_tArgList;
5725}
5726
5731
5733{
5734 return m_grpId;
5735}
5736
5741
5743{
5744 return m_hasCallGraph;
5745}
5746
5748{
5749 bool enabled = m_hasCallGraph &&
5750 (isFunction() || isSlot() || isSignal()) &&
5751 Config_getBool(HAVE_DOT);
5752 if (enabled)
5753 {
5754 bool trivial = DotCallGraph::isTrivial(this,false);
5755 return !trivial;
5756 }
5757 return false;
5758}
5759
5761{
5762 return m_hasCallerGraph;
5763}
5764
5766{
5767 bool enabled = m_hasCallerGraph &&
5768 (isFunction() || isSlot() || isSignal()) &&
5769 Config_getBool(HAVE_DOT);
5770 if (enabled)
5771 {
5772 bool trivial = DotCallGraph::isTrivial(this,true);
5773 return !trivial;
5774 }
5775 return false;
5776}
5777
5782
5787
5789{
5790 return m_hasInlineSource;
5791}
5792
5794{
5795 return m_hasEnumValues;
5796}
5797
5799{
5800 return m_templateMaster;
5801}
5802
5803std::optional<ArgumentList> MemberDefImpl::formalTemplateArguments() const
5804{
5806}
5807
5809{
5810 return m_isTypedefValCached;
5811}
5812
5817
5822
5824{
5825 //printf("MemberDefImpl::getCachedResolvedTypedef()=%s\n",qPrint(m_cachedResolvedType));
5826 return m_cachedResolvedType;
5827}
5828
5830{
5831 return m_memDef;
5832}
5833
5835{
5836 return m_memDec;
5837}
5838
5840{
5841 return m_docProvider;
5842}
5843
5845{
5846 return m_groupAlias;
5847}
5848
5853
5855{
5856 return m_declLine;
5857}
5858
5860{
5861 return m_declColumn;
5862}
5863
5864
5865//----------------------------------------------
5866
5872
5874{
5875 m_def=d;
5876}
5877
5885
5887{
5888 m_moduleDef=mod;
5889}
5890
5896
5901
5906
5911
5916
5918{
5919 for (const auto &sx : qualifiers)
5920 {
5921 bool alreadyAdded = std::find(m_qualifiers.begin(), m_qualifiers.end(), sx) != m_qualifiers.end();
5922 if (!alreadyAdded)
5923 {
5924 m_qualifiers.push_back(sx);
5925 }
5926 }
5927}
5928
5933
5935{
5936 if (lines!=-1)
5937 {
5938 m_userInitLines=lines;
5939 }
5940}
5941
5943{
5944 m_read=r;
5945}
5946
5948{
5949 m_write=w;
5950}
5951
5953{
5954 m_tspec=b;
5955}
5956
5958{
5959 m_related = Relationship::Related;
5961}
5962
5964{
5965 m_related = Relationship::Foreign;
5967}
5968
5970{
5971 m_docProvider = md;
5972}
5973
5975{
5976 m_args = as;
5977}
5978
5983
5990
5992{
5993 m_docEnumValues=value;
5994}
5995
5997{
5998 m_annEnumType = md;
5999}
6000
6005
6010
6011void MemberDefImpl::setPrototype(bool p,const DString &df,int line,size_t column)
6012{
6013 m_proto=p;
6014 if (p)
6015 {
6016 setDeclFile(df,line,column);
6017 }
6018 else
6019 {
6020 setDefFile(df,line,column);
6021 }
6022}
6023
6024void MemberDefImpl::setExplicitExternal(bool b,const DString &df,int line,size_t column)
6025{
6026 m_explExt=b;
6027 if (b)
6028 {
6029 setDeclFile(df,line,column);
6030 }
6031 else
6032 {
6033 setDefFile(df,line,column);
6034 }
6035}
6036
6037void MemberDefImpl::setDeclFile(const DString &df,int line,size_t column)
6038{
6039 m_declFileName = df;
6040 m_declLine = line;
6041 m_declColumn = column;
6042}
6043
6045{
6046 m_grpId=id;
6047}
6048
6053
6059
6064
6069
6071{
6072 m_groupAlias = md;
6073}
6074
6079
6084
6089
6091{
6092 return m_category;
6093}
6094
6096{
6097 m_category = def;
6098}
6099
6101{
6102 return m_categoryRelation;
6103}
6104
6109
6111{
6112 m_enumBaseType = type;
6113}
6114
6116{
6117 return m_enumBaseType;
6118}
6119
6121{
6122 m_requiresClause = req;
6123}
6124
6129
6130void MemberDefImpl::cacheTypedefVal(const ClassDef*val, const DString & templSpec, const DString &resolvedType)
6131{
6134 m_cachedTypedefTemplSpec=templSpec;
6135 m_cachedResolvedType=resolvedType;
6136 //printf("MemberDefImpl::cacheTypedefVal=%s m_impl=%p\n",qPrint(m_cachedResolvedType),m_impl);
6137}
6138
6140{
6141 {
6142 const ArgumentList &srcAl = bmd->argumentList();
6143 ArgumentList &dstAl = m_defArgList;
6144 auto srcIt = srcAl.begin();
6145 auto dstIt = dstAl.begin();
6146 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6147 {
6148 Argument &argDst = *dstIt;
6149 const Argument &argSrc = *srcIt;
6150 if (!argSrc.name.empty())
6151 {
6152 argDst.name = argSrc.name;
6153 }
6154 argDst.docs = argSrc.docs;
6155 ++srcIt;
6156 ++dstIt;
6157 }
6158 }
6159
6160 {
6161 const ArgumentList &srcAl = bmd->declArgumentList();
6162 ArgumentList &dstAl = m_declArgList;
6163 auto srcIt = srcAl.begin();
6164 auto dstIt = dstAl.begin();
6165
6166 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6167 {
6168 Argument &argDst = *dstIt;
6169 const Argument &argSrc = *srcIt;
6170 if (!argSrc.name.empty())
6171 {
6172 argDst.name = argSrc.name;
6173 }
6174 argDst.docs = argSrc.docs;
6175 ++srcIt;
6176 ++dstIt;
6177 }
6178 }
6179}
6180
6182{
6183 for (Argument &a : al)
6184 {
6185 a.canType.clear();
6186 }
6187}
6188
6194
6199
6201{
6202 return m_numberOfFlowKW;
6203}
6204
6205//----------------
6206
6208{
6209 return DefinitionMixin::name();
6210}
6211
6212//----------------
6213
6215{
6216 for (auto decIt = decAl.begin(), defIt = defAl.begin();
6217 decIt!= decAl.end() && defIt!= defAl.end();
6218 ++decIt, ++defIt)
6219 {
6220 Argument &decA = *decIt;
6221 Argument &defA = *defIt;
6222 if (decA.docs.empty() && !defA.docs.empty())
6223 {
6224 decA.docs = defA.docs;
6225 }
6226 else if (defA.docs.empty() && !decA.docs.empty())
6227 {
6228 defA.docs = decA.docs;
6229 }
6230 //printf("transferArgumentDocumentation(%s<->%s)\n",qPrint(decA.name),qPrint(defA.name));
6231 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6232 {
6233 if (decA.name.empty() && !defA.name.empty())
6234 {
6235 decA.name = defA.name;
6236 }
6237 else if (defA.name.empty() && !decA.name.empty())
6238 {
6239 defA.name = decA.name;
6240 }
6241 }
6242 }
6243}
6244
6245// returns true if the documentation has a \param or @param command or a <param> tag
6246static bool hasParamCommand(const DString &doc)
6247{
6248 size_t i=0;
6249 while ((i=doc.find("param",i))!=DString::npos)
6250 {
6251 if (i>0 && (i+5>=doc.length() || !isId(doc[i+5])))
6252 {
6253 char c = doc[i-1];
6254 // a command needs whitespace before it, so that e.g. an e-mail address does not count
6255 if (c=='<' || ((c=='\\' || c=='@') && (i==1 || disspace(doc[i-2]))))
6256 {
6257 return true;
6258 }
6259 }
6260 i+=5;
6261 }
6262 return false;
6263}
6264
6266{
6267 AUTO_TRACE("mdec='{}' mdef='{}' mdec.isPrototype={} mdef.isPrototype={}",
6268 mdec->name(), mdef->name(), mdec->isPrototype(), mdef->isPrototype());
6269 if (
6270 (!mdef->isDocTransferDone() || !mdec->isDocTransferDone()) &&
6271 (
6272 (mdef->isFunction() && !mdef->isStatic() && !mdef->isPrototype()) ||
6273 (mdef->isVariable() && !mdef->isExternal() && !mdef->isStatic())
6274 )
6275 )
6276 {
6277 bool sameNumTemplateArgs = mdef->templateArguments().size()==mdec->templateArguments().size();
6278
6279 ArgumentList &mdefAl = const_cast<ArgumentList&>(mdef->argumentList());
6280 ArgumentList &mdecAl = const_cast<ArgumentList&>(mdec->argumentList());
6281 if (sameNumTemplateArgs &&
6282 matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),mdef->typeString(),&mdefAl,
6283 mdec->getOuterScope(),mdec->getFileDef(),mdec->typeString(),&mdecAl,
6284 true,mdef->getLanguage()
6285 )
6286 ) /* match found */
6287 {
6288 AUTO_TRACE_ADD("combining definition and declaration");
6289
6290 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6291 {
6292 mdec->resolveUnnamedParameters(mdef);
6293 }
6294
6295 // check if the definition documents its own parameters, before the documentation is merged
6296 bool mdefHasParamDocs = hasParamCommand(mdef->documentation());
6297 for (const Argument &a : mdefAl)
6298 {
6299 if (!a.docs.empty()) mdefHasParamDocs = true; // e.g. with ///< comments
6300 }
6301
6302 // first merge argument documentation
6303 transferArgumentDocumentation(mdecAl,mdefAl);
6304
6305 // get the detailed descriptions before the brief descriptions are copied, since a brief
6306 // description copied to a member that already has one is added to its detailed description
6307 DString mdefDocs = mdef->documentation();
6308 DString mdecDocs = mdec->documentation();
6309 DString mdefFile = mdef->docFile();
6310 DString mdecFile = mdec->docFile();
6311 int mdefLine = mdef->docLine();
6312 int mdecLine = mdec->docLine();
6313 bool mdefDocsForDef = mdef->isDocsForDefinition();
6314 bool mdecDocsForDef = mdec->isDocsForDefinition();
6315
6316 // copy brief description between definition and declaration
6317 DString mdefBrief = mdef->briefDescription();
6318 DString mdecBrief = mdec->briefDescription();
6319 DString mdefBriefFile = mdef->briefFile();
6320 DString mdecBriefFile = mdec->briefFile();
6321 int mdefBriefLine = mdef->briefLine();
6322 int mdecBriefLine = mdec->briefLine();
6323 if (!mdef->isDocTransferDone() && !mdecBrief.empty())
6324 {
6325 mdef->setBriefDescription(mdecBrief,mdecBriefFile,mdecBriefLine);
6326 }
6327 if (!mdec->isDocTransferDone() && !mdefBrief.empty())
6328 {
6329 mdec->setBriefDescription(mdefBrief,mdefBriefFile,mdefBriefLine);
6330 }
6331
6332 // copy detailed description between definition and declaration
6333 if (!mdec->isDocTransferDone() && !mdefDocs.empty())
6334 {
6335 //printf("transferring docs mdef->mdec (%s->%s)\n",mdef->argsString(),mdec->argsString());
6336 mdec->setDocumentation(mdefDocs,mdefFile,mdefLine);
6337 mdec->setDocsForDefinition(mdefDocsForDef);
6338 if (mdefAl.hasParameters())
6339 {
6340 auto mdefAlComb = stringToArgumentList(mdef->getLanguage(),mdef->argsString());
6341 transferArgumentDocumentation(mdefAl,*mdefAlComb);
6342 mdec->moveArgumentList(std::move(mdefAlComb));
6343 }
6344 }
6345 if (!mdef->isDocTransferDone() && !mdecDocs.empty())
6346 {
6347 //printf("transferring docs mdec->mdef (%s->%s)\n",mdec->argsString(),mdef->argsString());
6348 mdef->setDocumentation(mdecDocs,mdecFile,mdecLine);
6349 // only use the parameters of the declaration if the definition does not document its own
6350 if (!mdefHasParamDocs)
6351 {
6352 mdef->setDocsForDefinition(mdecDocsForDef);
6353 if (mdecAl.hasParameters())
6354 {
6355 auto mdecAlComb = stringToArgumentList(mdec->getLanguage(),mdec->argsString());
6356 transferArgumentDocumentation(mdecAl,*mdecAlComb);
6357 mdef->moveDeclArgumentList(std::move(mdecAlComb));
6358 }
6359 }
6360 }
6361
6362 // copy inbody documentation between definition and declaration
6363 DString mdefInbodyDocs = mdef->inbodyDocumentation();
6364 DString mdecInbodyDocs = mdec->inbodyDocumentation();
6365 DString mdefInbodyFile = mdef->inbodyFile();
6366 DString mdecInbodyFile = mdec->inbodyFile();
6367 int mdefInbodyLine = mdef->inbodyLine();
6368 int mdecInbodyLine = mdec->inbodyLine();
6369 if (!mdec->isDocTransferDone() && !mdefInbodyDocs.empty())
6370 {
6371 mdec->setInbodyDocumentation(mdefInbodyDocs,mdefInbodyFile,mdefInbodyLine);
6372 }
6373 if (!mdef->isDocTransferDone() && !mdecInbodyDocs.empty())
6374 {
6375 mdef->setInbodyDocumentation(mdecInbodyDocs,mdecInbodyFile,mdecInbodyLine);
6376 }
6377
6378 if (mdec->getStartBodyLine()!=-1 && mdef->getStartBodyLine()==-1)
6379 {
6380 //printf("body mdec->mdef %d-%d\n",mdec->getStartBodyLine(),mdef->getEndBodyLine());
6381 mdef->setBodySegment(mdec->getDefLine(),mdec->getStartBodyLine(),mdec->getEndBodyLine());
6382 mdef->setBodyDef(mdec->getBodyDef());
6383 //mdef->setBodyMember(mdec);
6384 }
6385 else if (mdef->getStartBodyLine()!=-1 && mdec->getStartBodyLine()==-1)
6386 {
6387 //printf("body mdef->mdec %d-%d\n",mdef->getStartBodyLine(),mdec->getEndBodyLine());
6388 mdec->setBodySegment(mdef->getDefLine(),mdef->getStartBodyLine(),mdef->getEndBodyLine());
6389 mdec->setBodyDef(mdef->getBodyDef());
6390 //mdec->setBodyMember(mdef);
6391 }
6394
6395 // copy group info.
6396 if (mdec->getGroupDef()==nullptr && mdef->getGroupDef()!=nullptr)
6397 {
6398 mdec->setGroupDef(mdef->getGroupDef(),
6399 mdef->getGroupPri(),
6400 mdef->docFile(),
6401 mdef->docLine(),
6402 mdef->hasDocumentation(),
6403 mdef
6404 );
6405 }
6406 else if (mdef->getGroupDef()==nullptr && mdec->getGroupDef()!=nullptr)
6407 {
6408 mdef->setGroupDef(mdec->getGroupDef(),
6409 mdec->getGroupPri(),
6410 mdec->docFile(),
6411 mdec->docLine(),
6412 mdec->hasDocumentation(),
6413 mdec
6414 );
6415 }
6416
6417
6418 mdec->mergeRefItems(mdef);
6419 mdef->mergeRefItems(mdec);
6420
6421 mdef->setMemberDeclaration(mdec);
6422 mdec->setMemberDefinition(mdef);
6423
6424 mergeMemberOverrideOptions(mdec,mdef);
6425
6426 mdef->addQualifiers(mdec->getQualifiers());
6427 mdec->addQualifiers(mdef->getQualifiers());
6428
6429 mdef->setDocTransferDone();
6430 mdec->setDocTransferDone();
6431 }
6432 }
6433}
6434
6436{
6437 if (Config_getBool(CALL_GRAPH) !=md1->hasCallGraph()) md2->overrideCallGraph(md1->hasCallGraph());
6438 if (Config_getBool(CALLER_GRAPH)!=md1->hasCallerGraph()) md2->overrideCallerGraph(md1->hasCallerGraph());
6439 if (Config_getBool(CALL_GRAPH) !=md2->hasCallGraph()) md1->overrideCallGraph( md2->hasCallGraph());
6440 if (Config_getBool(CALLER_GRAPH)!=md2->hasCallerGraph()) md1->overrideCallerGraph(md2->hasCallerGraph());
6441
6442 if (Config_getBool(SHOW_ENUM_VALUES) !=md1->hasEnumValues()) md2->overrideEnumValues(md1->hasEnumValues());
6443 if (Config_getBool(SHOW_ENUM_VALUES) !=md2->hasEnumValues()) md1->overrideEnumValues( md2->hasEnumValues());
6444
6445 if (Config_getBool(REFERENCED_BY_RELATION)!=md1->hasReferencedByRelation()) md2->overrideReferencedByRelation(md1->hasReferencedByRelation());
6446 if (Config_getBool(REFERENCES_RELATION) !=md1->hasReferencesRelation()) md2->overrideReferencesRelation(md1->hasReferencesRelation());
6447 if (Config_getBool(REFERENCED_BY_RELATION)!=md2->hasReferencedByRelation()) md1->overrideReferencedByRelation(md2->hasReferencedByRelation());
6448 if (Config_getBool(REFERENCES_RELATION) !=md2->hasReferencesRelation()) md1->overrideReferencesRelation(md2->hasReferencesRelation());
6449
6450 if (Config_getBool(INLINE_SOURCES)!=md1->hasInlineSource()) md2->overrideInlineSource(md1->hasInlineSource());
6451 if (Config_getBool(INLINE_SOURCES)!=md2->hasInlineSource()) md1->overrideInlineSource(md2->hasInlineSource());
6452}
6453
6455{
6456 if (m_templateMaster)
6457 {
6458 return m_templateMaster->briefDescription(abbr);
6459 }
6460 else
6461 {
6463 }
6464}
6465
6467{
6468 if (m_templateMaster)
6469 {
6471 }
6472 else
6473 {
6475 }
6476}
6477
6479{
6480 if (m_templateMaster)
6481 {
6483 }
6484 else
6485 {
6487 }
6488}
6489
6491{
6492 return m_typeConstraints;
6493}
6494
6495
6497 const DString &includeName,bool local, bool force)
6498{
6499 if (!force || includeName.empty()) return;
6500 //printf("MemberDefImpl::setIncludeFile(%p,%s,%d,%d)\n",fd,includeName,local,force);
6501 if (!m_incInfo) m_incInfo = std::make_unique<IncludeInfo>();
6502 m_incInfo->fileDef = fd;
6503 m_incInfo->includeName = includeName;
6505}
6506
6508{
6509 bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
6510 bool isFriendToHide = hideFriendCompounds && isTypeAClassFriend(m_type);
6511 return isFriendToHide;
6512}
6513
6515{
6516 return isFriend() && isTypeAClassFriend(m_type);
6517}
6518
6519
6521{
6522 return !(isFriend() && isFriendToHide());
6523}
6524
6526{
6527 return isFunction() || isSlot() || isSignal();
6528}
6529
6531{
6532 return isRelated() || isForeign() || (isFriend() && !isFriendToHide());
6533}
6534
6540
6542{
6543 switch (memberType())
6544 {
6545 case MemberType::Define: return CodeSymbolType::Define;
6546 case MemberType::Function: return CodeSymbolType::Function;
6547 case MemberType::Variable: return CodeSymbolType::Variable;
6548 case MemberType::Typedef: return CodeSymbolType::Typedef;
6549 case MemberType::Enumeration: return CodeSymbolType::Enumeration;
6550 case MemberType::EnumValue: return CodeSymbolType::EnumValue;
6551 case MemberType::Signal: return CodeSymbolType::Signal;
6552 case MemberType::Slot: return CodeSymbolType::Slot;
6553 case MemberType::Friend: return CodeSymbolType::Friend;
6554 case MemberType::DCOP: return CodeSymbolType::DCOP;
6555 case MemberType::Property: return CodeSymbolType::Property;
6556 case MemberType::Event: return CodeSymbolType::Event;
6557 case MemberType::Interface: return CodeSymbolType::Interface;
6558 case MemberType::Service: return CodeSymbolType::Service;
6559 case MemberType::Sequence: return CodeSymbolType::Sequence;
6560 case MemberType::Dictionary: return CodeSymbolType::Dictionary;
6561 }
6563}
6564
6566{
6567 return m_redefineCount;
6568}
6569
6571{
6572 m_redefineCount=count;
6573}
6574
6575//-------------------------------------------------------------------------------
6576// Helpers
6577
6579
6581{
6582 MemberDefMutable *src = toMemberDefMutable(const_cast<MemberDef*>(s));
6583 MemberDefMutable *dst = toMemberDefMutable(const_cast<MemberDef*>(d));
6584 if (src==nullptr || dst==nullptr) return;
6585 //printf("--> addDocCrossReference src=%s,dst=%s\n",qPrint(src->name()),qPrint(dst->name()));
6586 if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types
6587 if ((dst->hasReferencedByRelation() || dst->hasCallerGraph()) &&
6588 src->isCallable()
6589 )
6590 {
6591 DString sourceRefName = src->sourceRefName();
6594
6595 // ---- critical section
6596 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6597 dst->addSourceReferencedBy(src,sourceRefName);
6598 if (mdDef)
6599 {
6600 mdDef->addSourceReferencedBy(src,sourceRefName);
6601 }
6602 if (mdDecl)
6603 {
6604 mdDecl->addSourceReferencedBy(src,sourceRefName);
6605 }
6606 // ---- end critical section
6607 }
6608 if ((src->hasReferencesRelation() || src->hasCallGraph()) &&
6609 src->isCallable()
6610 )
6611 {
6612 DString sourceRefName = dst->sourceRefName();
6615
6616 // ---- critical section
6617 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6618 src->addSourceReferences(dst,sourceRefName);
6619 if (mdDef)
6620 {
6621 mdDef->addSourceReferences(dst,sourceRefName);
6622 }
6623 if (mdDecl)
6624 {
6625 mdDecl->addSourceReferences(dst,sourceRefName);
6626 }
6627 // ---- end critical section
6628 }
6629}
6630
6631// --- Cast functions
6632//
6634{
6635 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6636 {
6637 return static_cast<MemberDef*>(d);
6638 }
6639 else
6640 {
6641 return nullptr;
6642 }
6643}
6644
6646{
6647 Definition *d = toDefinition(md);
6648 if (d && typeid(*d)==typeid(MemberDefImpl))
6649 {
6650 return static_cast<MemberDef*>(d);
6651 }
6652 else
6653 {
6654 return nullptr;
6655 }
6656}
6657
6659{
6660 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6661 {
6662 return static_cast<const MemberDef*>(d);
6663 }
6664 else
6665 {
6666 return nullptr;
6667 }
6668}
6669
6671{
6672 if (d && typeid(*d)==typeid(MemberDefImpl))
6673 {
6674 return static_cast<MemberDefMutable*>(d);
6675 }
6676 else
6677 {
6678 return nullptr;
6679 }
6680}
6681
6682
constexpr auto prefix
Definition anchor.cpp:47
This class contains the information about the argument of a function or template.
Definition arguments.h:27
DString docs
Definition arguments.h:48
DString attrib
Definition arguments.h:42
DString defval
Definition arguments.h:47
DString array
Definition arguments.h:46
DString name
Definition arguments.h:45
DString type
Definition arguments.h:43
This class represents an function or template argument list.
Definition arguments.h:66
RefQualifierType refQualifier() const
Definition arguments.h:117
iterator end()
Definition arguments.h:95
bool hasParameters() const
Definition arguments.h:77
Argument & front()
Definition arguments.h:106
DString trailingReturnType() const
Definition arguments.h:115
bool isDeleted() const
Definition arguments.h:116
size_t size() const
Definition arguments.h:101
bool constSpecifier() const
Definition arguments.h:112
bool hasDocumentation(bool allowEmptyNames=false) const
Definition arguments.cpp:26
bool empty() const
Definition arguments.h:100
bool hasTemplateDocumentation() const
Definition arguments.cpp:34
iterator begin()
Definition arguments.h:94
bool volatileSpecifier() const
Definition arguments.h:113
A abstract class representing of a compound symbol.
Definition classdef.h:100
virtual void writeDeclaration(OutputList &ol, bool inGroup, int indentLevel, const ClassDef *inheritedFrom, const DString &inheritId) const =0
virtual int isBaseClass(const ClassDef *bcd, bool followInstances, const DString &templSpec=DString()) 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 bool isObjectiveC() const =0
Returns true if this class is implemented in Objective-C.
virtual bool isSimple() const =0
virtual DString compoundTypeString() const =0
Returns the type of compound as a string.
virtual ClassDef * categoryOf() const =0
Returns the class of which this is a category (Objective-C only).
virtual bool isImplicitTemplateInstance() const =0
@ Interface
Definition classdef.h:109
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e. class/struct/union/...
A String class for use with Doxygen wrapping std::string and adding some additional functionality off...
Definition dstring.h:84
void clear()
Definition dstring.h:214
size_t rfind(char c, size_t pos=npos) const
Definition dstring.h:244
DString mid(size_t index, size_t len=npos) const
Definition dstring.h:318
DString lower() const
Definition dstring.h:326
DString simplifyWhiteSpace() const
return a copy of this string with leading and trailing whitespace removed and multiple internal white...
Definition dstring.cpp:127
bool empty() const
Returns true iff the string is empty (std::string compatible alias for isEmpty()).
Definition dstring.h:148
std::string_view view() const
Definition dstring.h:162
DString & remove(size_t index, size_t len)
Definition dstring.h:535
static constexpr size_t npos
value used to indicate 'not found' or 'to the end of the string', matching std::string::npos
Definition dstring.h:178
char & at(size_t i)
Returns a reference to the character at index i.
Definition dstring.h:686
DString & append(char c)
Definition dstring.h:489
DString right(size_t len) const
Definition dstring.h:311
DString & prepend(const char *s)
Definition dstring.h:515
int contains(char c, bool cs=true) const
Definition dstring.cpp:85
size_t find(char c, size_t pos=0) const
Definition dstring.h:239
DString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition dstring.h:337
DString left(size_t len) const
Definition dstring.h:306
const std::string & str() const
Definition dstring.h:645
bool stripPrefix(const DString &prefix)
Definition dstring.h:290
bool startsWith(const char *s) const
Definition dstring.h:600
bool endsWith(const char *s) const
Definition dstring.h:617
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition dstring.h:151
const Definition * getAlias() const
const Definition * getScope() const
DefinitionAliasMixin(const Definition *scope, const Definition *alias)
The common base class of all entity definitions found in the sources.
Definition definition.h:77
virtual DString briefDescription(bool abbreviate=false) const =0
virtual DString inbodyFile() const =0
virtual int getEndBodyLine() const =0
virtual DString briefFile() const =0
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
virtual int docLine() const =0
virtual DString getDefFileName() const =0
virtual DString documentation() const =0
virtual bool isLinkable() const =0
virtual DString inbodyDocumentation() const =0
virtual int getDefLine() const =0
virtual DefType definitionType() const =0
virtual const DString & name() const =0
virtual const DString & localName() 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 bool hasUserDocumentation() const =0
virtual bool isAnonymous() const =0
virtual DString displayName(bool includeScope=true) const =0
virtual DString qualifiedName() const =0
virtual DString anchor() const =0
virtual DString getReference() const =0
virtual CodeSymbolType codeSymbolType() const =0
virtual Definition * getOuterScope() const =0
virtual DString docFile() const =0
virtual int getStartBodyLine() const =0
virtual bool isReference() const =0
virtual DString getOutputFileBase() const =0
bool isReference() const override
DString docFile() const override
void writeSourceDef(OutputList &ol) const override
bool hasUserDocumentation() const override
DString qualifiedName() const override
bool hasBriefDescription() const override
void setDefFile(const DString &df, int defLine, size_t defColumn) override
DString briefFile() const override
bool hasRequirementRefs() const override
DString briefDescription(bool abbreviate=false) const override
const DString & name() const override
DString inbodyFile() const override
void setOuterScope(Definition *def) override
DString getReference() const override
void writeRequirementRefs(OutputList &ol) const override
void setInbodyDocumentation(const DString &doc, const DString &docFile, int docLine) override
const RefItemVector & xrefListItems() const override
bool hasSourceReffedBy() const override
size_t getDefColumn() const override
Definition * getOuterScope() const override
void setBriefDescription(const DString &brief, const DString &briefFile, int briefLine) override
void setDocumentation(const DString &doc, const DString &docFile, int docLine, bool stripWhiteSpace=true) override
const DString & localName() const override
void setReference(const DString &r) override
DString getDefFileExtension() const override
DString getDefFileName() const override
DString documentation() const override
DefinitionMixin(const DString &defFileName, int defLine, size_t defColumn, const DString &name, const char *b=nullptr, const char *d=nullptr, bool isSymbol=true)
const FileDef * getBodyDef() const override
DString inbodyDocumentation() const override
void writeSourceReffedBy(OutputList &ol, const DString &scopeName) const override
void writeInlineCode(OutputList &ol, const DString &scopeName) const override
void setHidden(bool b) override
DString getSourceFileBase() const override
void writeDocAnchorsToTagFile(TextStream &fs) const override
bool hasDocumentation() const override
void writeSourceRefs(OutputList &ol, const DString &scopeName) const override
SrcLangExt getLanguage() const override
virtual void setBodySegment(int defLine, int bls, int ble)=0
virtual void setInbodyDocumentation(const DString &d, const DString &docFile, int docLine)=0
virtual void setDocumentation(const DString &d, const DString &docFile, int docLine, bool stripWhiteSpace=true)=0
virtual void addSourceReferences(MemberDef *d, const DString &sourceRefName)=0
virtual void addSourceReferencedBy(MemberDef *d, const DString &sourceRefName)=0
virtual void setBriefDescription(const DString &b, const DString &briefFile, int briefLine)=0
virtual void mergeRefItems(Definition *d)=0
virtual void setBodyDef(const FileDef *fd)=0
Representation of an call graph.
int numNodes() const
bool isTooBig() const
bool isTrivial() const
static bool suppressDocWarnings
Definition doxygen.h:123
static bool parseSourcesNeeded
Definition doxygen.h:116
static ParserManager * parserManager
Definition doxygen.h:122
static NamespaceDefMutable * globalScope
Definition doxygen.h:114
bool inSort(const Example &ex)
Definition example.h:39
A model of a file symbol.
Definition filedef.h:97
virtual DString absFilePath() const =0
A model of a group of symbols.
Definition groupdef.h:48
bool hasEnumValues() const override
bool isConstEval() const override
const ClassDef * getCachedTypedefVal() const override
NamespaceDef * getNamespaceDef() override
const NamespaceDef * getNamespaceDef() const override
bool hasExamples() const override
DString getGroupFileName() const override
GroupDef * getGroupDef() override
bool isSettable() const override
bool isConstrained() const override
bool getGroupHasDocs() const override
const ClassDef * getClassDef() const override
const MemberDef * inheritsDocsFrom() const override
bool hasCallerGraph() const override
bool isConstInit() const override
bool isFinal() const override
void writeLink(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool onlyText=false) const override
const MemberDef * reimplements() const override
DString argsString() const override
const DString & initializer() const override
bool isOptional() const override
const ClassDef * getClassDefOfAnonymousType() const override
bool isTypeAlias() const override
bool isRequired() const override
bool isRemovable() const override
void setMemberGroup(MemberGroup *grp) override
bool isDeleted() const override
bool isPrivateGettable() const override
bool isSignal() const override
MemberDef * memberDeclaration() const override
size_t getDeclColumn() const override
bool isFriendClass() const override
const MemberDef * getGroupAlias() const override
bool isStrongEnumValue() const override
bool isAssign() const override
DString typeString() const override
int getGroupStartLine() const override
std::unique_ptr< MemberDef > deepCopy() const override
bool isUNOProperty() const override
void warnIfUndocumented() const override
bool hasUserDocumentation() const override
DString getOutputFileBase() const override
bool isSliceLocal() const override
const ArgumentLists & definitionTemplateParameterLists() const override
bool isPublished() const override
bool isSequence() const override
bool isDictionary() const override
bool isVariable() const override
FileDef * getFileDef() override
const MemberDef * templateMaster() const override
void warnIfUndocumentedParams() const override
const MemberDef * anonymousMemberForDetails() const override
bool isExternal() const override
DString excpString() const override
bool isProperty() const override
bool isWritable() const override
bool isDocumentedFriendClass() const override
int redefineCount() const override
bool isConstExpr() const override
int initializerLines() const override
bool isMaybeVoid() const override
int getMemberGroupId() const override
DString objCMethodName(bool localLink, bool showStatic) const override
bool isInitonly() const override
const ExampleList & getExamples() const override
bool hasOneLineInitializer() const override
bool isProtectedGettable() const override
bool hasDocumentation() const override
bool livesInsideEnum() const override
bool hasCallGraph() const override
bool isCopy() const override
DString displayDefinition() const override
DString getWriteAccessor() const override
int getDeclLine() const override
bool isEnumerate() const override
DString getReference() const override
void writeDeclaration(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool inGroup, int indentLevel, const ClassDef *inheritFrom=nullptr, const DString &inheritId=DString(), const DString &declAnchor=DString()) const override
bool isReference() const override
TypeSpecifier getMemberSpecifiers() const override
bool isThreadLocal() const override
bool hasMultiLineInitializer() const override
bool isDocsForDefinition() const override
Grouping::GroupPri_t getGroupPri() const override
bool isTypedefValCached() const override
bool isRaisable() const override
bool isUnretained() const override
bool isGettable() const override
const MemberVector & enumFieldList() const override
DString anchor() const override
bool isObjCProperty() const override
DString qualifiedName() const override
const ArgumentList & declArgumentList() const override
DString briefDescription(bool) const override
bool isCallable() const override
bool isDefine() const override
bool isLinkableInProject() const override
bool hasDetailedDescription() const override
bool isFriendToHide() const override
DString getCachedTypedefTemplSpec() const override
const MemberDef * anonymousMemberForDeclaration() const override
const GroupDef * getGroupDef() const override
bool isDestructor() const override
bool isNoDiscard() const override
bool hasDocumentedEnumValues() const override
bool isBound() const override
void detectUndocumentedParams(bool, bool) const override
DString requiresClause() const override
bool isFunctionPtr() const override
StringVector getLabels(const Definition *container) const override
std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const override
bool isAddable() const override
const ArgumentList & argumentList() const override
const ArgumentList & typeConstraints() const override
Specifier virtualness(int) const override
bool isFunctionOrSignalSlot() const override
bool isDefault() const override
bool isPrototype() const override
bool isAttribute() const override
MemberDef * memberDefinition() const override
bool isTypedef() const override
bool isNoExcept() const override
bool isInline() const override
bool isRelatedOrFriend() const override
bool hasReferencesRelation() const override
bool isStrong() const override
const MemberDef * getMdAlias() const
bool isObjCMethod() const override
const DString & name() const override
bool isAbstract() const override
DString extraTypeChars() const override
bool isStatic() const override
bool isPrivateSettable() const override
bool isSealed() const override
bool isRelated() const override
MemberDef * getMdAlias()
DString memberTypeName() const override
bool isOverride() const override
bool isForeign() const override
bool isImplementation() const override
const MemberVector & reimplementedBy() const override
VhdlSpecifier getVhdlSpecifiers() const override
bool isMaybeDefault() const override
MemberType memberType() const override
bool isLinkable() const override
DString getDeclFileName() const override
bool isProtectedSettable() const override
bool isReadonly() const override
DString declaration() const override
DString getCachedResolvedTypedef() const override
const MemberDef * categoryRelation() const override
ClassDef * getClassDef() override
DString documentation() const override
MemberDefAliasImpl(const Definition *newScope, const MemberDef *md)
const MemberDef * getEnumScope() const override
DString getReadAccessor() const override
Protection protection() const override
bool isSlot() const override
DString displayName(bool b=true) const override
bool isDelete() const override
bool isReadable() const override
bool isEvent() const override
bool isNonAtomic() const override
DefType definitionType() const override
DString getScopeString() const override
bool isReimplementedBy(const ClassDef *cd) const override
bool isDCOP() const override
DString bitfieldString() const override
void writeEnumDeclaration(OutputList &typeDecl, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod) const override
bool isDocTransferDone() const override
bool isDetailedSectionVisible(MemberListContainer container) const override
bool isNotFriend() const override
const MemberList * getSectionList(const Definition *container) const override
bool isTemplateSpecialization() const override
const ModuleDef * getModuleDef() const override
bool isExplicit() const override
DString enumBaseType() const override
CodeSymbolType codeSymbolType() const override
bool isConstructor() const override
bool isTransient() const override
int numberOfFlowKeyWords() const override
bool isFriend() const override
bool isWeak() const override
bool isMutable() const override
MemberDef * resolveAlias() override
const FileDef * getFileDef() const override
std::optional< ArgumentList > formalTemplateArguments() const override
DString sourceRefName() const override
DString definition() const override
const MemberDef * resolveAlias() const override
bool isEnumValue() const override
bool isNew() const override
const MemberDef * getAnonymousEnumType() const override
bool isMaybeAmbiguous() const override
bool hasReferencedByRelation() const override
DString fieldType() const override
bool isCSharpProperty() const override
bool hasInlineSource() const override
ClassDef * category() const override
void moveTo(Definition *) override
MemberGroup * getMemberGroup() const override
MemberGroup * m_memberGroup
bool isFunction() const override
DString getDeclType() const override
bool visibleInIndex() const override
ClassDef * relatedAlso() const override
bool isRetain() const override
bool isEnumStruct() const override
bool isBriefSectionVisible() const override
const ArgumentList & templateArguments() const override
~MemberDefAliasImpl() override
StringVector getQualifiers() const override
A model of a class/file/namespace member symbol.
Definition memberdef.h:45
virtual bool isConstExpr() const =0
virtual bool getGroupHasDocs() const =0
virtual const MemberDef * getAnonymousEnumType() const =0
virtual bool isConstEval() const =0
virtual bool isInitonly() const =0
virtual bool isSignal() const =0
virtual bool isNoExcept() const =0
virtual bool isDestructor() const =0
virtual DString getDeclType() const =0
virtual bool hasDetailedDescription() const =0
virtual bool isAssign() const =0
virtual bool isExplicit() const =0
virtual MemberDef * memberDefinition() const =0
virtual bool isNew() const =0
virtual bool isObjCMethod() const =0
virtual bool hasDocumentedEnumValues() const =0
virtual MemberDef * memberDeclaration() const =0
virtual DString requiresClause() const =0
virtual bool isMaybeVoid() const =0
virtual bool isConstructor() const =0
virtual bool isFriend() const =0
virtual void writeEnumDeclaration(OutputList &typeDecl, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod) const =0
virtual DString argsString() const =0
virtual bool isForeign() const =0
virtual bool isSealed() const =0
virtual bool hasExamples() const =0
virtual bool isDelete() const =0
virtual int numberOfFlowKeyWords() const =0
virtual const MemberDef * inheritsDocsFrom() const =0
virtual bool isDefault() const =0
virtual DString objCMethodName(bool localLink, bool showStatic) const =0
virtual bool isRelated() const =0
virtual bool isDocumentedFriendClass() const =0
virtual bool isConstInit() const =0
virtual bool isDeleted() const =0
virtual DString definition() const =0
virtual const ClassDef * getCachedTypedefVal() const =0
virtual bool isRelatedOrFriend() const =0
virtual bool isSequence() const =0
virtual bool isEnumStruct() const =0
virtual const ClassDef * getClassDef() const =0
virtual bool visibleInIndex() const =0
virtual const MemberDef * getGroupAlias() const =0
virtual bool isOverride() const =0
virtual bool hasReferencesRelation() const =0
virtual DString declaration() const =0
virtual DString excpString() const =0
virtual DString getCachedResolvedTypedef() const =0
virtual const ArgumentList & templateArguments() const =0
virtual DString getDeclFileName() const =0
virtual const DString & initializer() const =0
virtual GroupDef * getGroupDef()=0
virtual bool isSettable() const =0
virtual bool isCSharpProperty() const =0
virtual bool isRetain() const =0
virtual bool isAddable() const =0
virtual bool isTypedef() const =0
virtual ClassDef * category() const =0
virtual bool isSlot() const =0
virtual const MemberVector & enumFieldList() const =0
virtual bool hasCallGraph() const =0
virtual const FileDef * getFileDef() const =0
virtual bool isInline() const =0
virtual bool isEvent() const =0
virtual DString getReadAccessor() const =0
virtual const ArgumentList & argumentList() const =0
virtual bool isWritable() const =0
virtual bool isMaybeAmbiguous() const =0
virtual bool isPrivateGettable() const =0
virtual bool isStrongEnumValue() const =0
virtual VhdlSpecifier getVhdlSpecifiers() const =0
virtual const MemberVector & reimplementedBy() const =0
virtual int getGroupStartLine() const =0
virtual bool isFunction() const =0
virtual bool isRequired() const =0
virtual bool isAttribute() const =0
virtual bool isExternal() const =0
virtual bool isCopy() const =0
virtual int getMemberGroupId() const =0
virtual bool isDictionary() const =0
virtual DString bitfieldString() const =0
virtual int getDeclLine() const =0
virtual bool isTypeAlias() const =0
virtual bool isStatic() const =0
virtual const MemberDef * reimplements() const =0
virtual bool isMaybeDefault() const =0
virtual bool livesInsideEnum() const =0
virtual bool hasInlineSource() const =0
virtual bool isTemplateSpecialization() const =0
virtual bool isPrivateSettable() const =0
virtual DString displayDefinition() const =0
virtual StringVector getQualifiers() const =0
virtual const MemberDef * anonymousMemberForDeclaration() const =0
virtual bool isRaisable() const =0
virtual bool isRemovable() const =0
virtual bool isTypedefValCached() const =0
virtual bool isConstrained() const =0
virtual DString getWriteAccessor() const =0
virtual bool isDocsForDefinition() const =0
virtual bool isBound() const =0
virtual bool hasEnumValues() const =0
virtual bool isFriendToHide() const =0
virtual bool isReimplementedBy(const ClassDef *cd) const =0
virtual bool isNonAtomic() const =0
virtual const ModuleDef * getModuleDef() const =0
virtual bool isThreadLocal() const =0
virtual bool isDefine() const =0
virtual DString extraTypeChars() const =0
virtual const NamespaceDef * getNamespaceDef() const =0
virtual bool isPublished() const =0
virtual DString getScopeString() const =0
virtual bool isFunctionPtr() const =0
virtual DString sourceRefName() const =0
virtual std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const =0
virtual bool hasCallerGraph() const =0
virtual Grouping::GroupPri_t getGroupPri() const =0
virtual const ArgumentList & typeConstraints() const =0
virtual const MemberDef * anonymousMemberForDetails() const =0
virtual size_t getDeclColumn() const =0
virtual bool isProtectedSettable() const =0
virtual const ClassDef * getClassDefOfAnonymousType() const =0
virtual bool isImplementation() const =0
virtual bool isProtectedGettable() const =0
virtual bool hasOneLineInitializer() const =0
virtual const MemberDef * templateMaster() const =0
virtual std::optional< ArgumentList > formalTemplateArguments() const =0
virtual bool isObjCProperty() const =0
virtual bool isTransient() const =0
virtual const MemberList * getSectionList(const Definition *container) const =0
virtual bool hasMultiLineInitializer() const =0
virtual void writeDeclaration(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *md, bool inGroup, int indentLevel=0, const ClassDef *inheritFrom=nullptr, const DString &inheritId=DString(), const DString &declAnchor=DString()) const =0
virtual Protection protection() const =0
virtual TypeSpecifier getMemberSpecifiers() const =0
virtual bool isOptional() const =0
virtual DString getCachedTypedefTemplSpec() const =0
virtual bool isEnumerate() const =0
virtual bool isGettable() const =0
virtual MemberType memberType() const =0
virtual bool hasReferencedByRelation() const =0
virtual bool isFunctionOrSignalSlot() const =0
virtual DString fieldType() const =0
virtual bool isReadable() const =0
virtual bool isWeak() const =0
virtual bool isDocTransferDone() const =0
virtual bool isNoDiscard() const =0
virtual DString enumBaseType() const =0
virtual bool isUnretained() const =0
virtual ClassDef * relatedAlso() const =0
virtual bool isBriefSectionVisible() const =0
virtual const ArgumentLists & definitionTemplateParameterLists() const =0
virtual StringVector getLabels(const Definition *container) const =0
virtual bool isVariable() const =0
virtual bool isNotFriend() const =0
virtual DString getGroupFileName() const =0
virtual bool isDCOP() const =0
virtual bool isStrong() const =0
virtual DString typeString() const =0
virtual bool isSliceLocal() const =0
virtual Specifier virtualness(int count=0) const =0
virtual bool isUNOProperty() const =0
virtual int redefineCount() const =0
virtual const MemberDef * categoryRelation() const =0
virtual int initializerLines() const =0
virtual bool isFinal() const =0
virtual const ArgumentList & declArgumentList() const =0
virtual const ExampleList & getExamples() const =0
virtual bool isAbstract() const =0
virtual DString memberTypeName() const =0
virtual bool isMutable() const =0
virtual bool isFriendClass() const =0
virtual bool isCallable() const =0
virtual bool isDetailedSectionVisible(MemberListContainer container) const =0
virtual const MemberDef * getEnumScope() const =0
virtual bool isEnumValue() const =0
virtual bool isPrototype() const =0
virtual void writeLink(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *md, bool onlyText=false) const =0
virtual bool isProperty() const =0
bool _hasVisibleCallerGraph() const
DString getCachedTypedefTemplSpec() const override
void _writeCallerGraph(OutputList &ol) const
void insertReimplementedBy(MemberDef *md) override
bool isDCOP() const override
DString enumBaseType() const override
VhdlSpecifier m_vhdlSpec
const MemberDef * anonymousMemberForDeclaration() const override
bool isDetailedSectionVisible(MemberListContainer container) const override
bool _isReimplements() const
bool isFunction() const override
void cacheTypedefVal(const ClassDef *val, const DString &templSpec, const DString &resolvedType) override
void overrideReferencesRelation(bool e) override
const MemberDef * reimplements() const override
MemberType m_mtype
int getMemberGroupId() const override
bool isProperty() const override
bool visibleInIndex() const override
const ArgumentList & argumentList() const override
void writeDocumentation(const MemberList *ml, int memCount, int memTotal, OutputList &ol, const DString &scopeName, const Definition *container, bool inGroup, bool showEnumValues=false, bool showInline=false) const override
void setDocumentedEnumValues(bool value) override
bool m_detailedDescriptionCachedValue
bool isTypedefValCached() const override
DString objCMethodName(bool localLink, bool showStatic) const override
bool isInline() const override
const ExampleList & getExamples() const override
ArgumentLists m_defTmpArgLists
DString getWriteAccessor() const override
bool isFriendToHide() const override
void invalidateTypedefValCache() override
bool isFriendClass() const override
void setNamespace(NamespaceDef *nd) override
void setProtection(Protection p) override
const NamespaceDef * getNamespaceDef() const override
void setHidden(bool b) override
void _writeTypeConstraints(OutputList &ol) const
bool isSliceLocal() const override
void makeRelated() override
int getGroupStartLine() const override
void setAnonymousMemberForDeclaration(const MemberDef *md) override
void warnIfUndocumented() const override
void writeDeclaration(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool inGroup, int indentLevel, const ClassDef *inheritFrom=nullptr, const DString &inheritId=DString(), const DString &declAnchor=DString()) const override
bool m_hasReferencedByRelation
void setMemberType(MemberType t) override
const ArgumentList & typeConstraints() const override
void setRequiresClause(const DString &req) override
DefType definitionType() const override
Definition memberdef.cpp:64
bool isDestructor() const override
StringVector getQualifiers() const override
Specifier m_virt
DString getDeclFileName() const override
void setRedefineCount(int) override
void setAnonymousEnumType(const MemberDef *md) override
bool isOptional() const override
void _writeExamples(OutputList &ol) const
void moveTo(Definition *) override
bool isCallable() const override
void setBriefDescription(const DString &b, const DString &briefFile, int briefLine) override
DString getScopeString() const override
bool m_docTransferDone
bool isBriefSectionVisible() const override
const MemberDef * m_categoryRelation
void setCategoryRelation(const MemberDef *) override
bool isReference() const override
DString m_cachedResolvedType
Protection m_prot
void warnIfUndocumentedParams() const override
VhdlSpecifier getVhdlSpecifiers() const override
bool _hasVisibleCallGraph() const
void setFormalTemplateArguments(const ArgumentList &al) override
ClassDef * m_category
DString extraTypeChars() const override
void setClassDefOfAnonymousType(const ClassDef *cd) override
bool isDefine() const override
void findSectionsInDocumentation() override
DString m_exception
DString displayDefinition() const override
void setFileDef(FileDef *fd) override
const MemberDef * resolveAlias() const override
Definition memberdef.cpp:66
ArgumentList m_declArgList
std::unique_ptr< MemberDef > deepCopy() const override
void makeForeign() override
MemberDef * m_memDec
uint8_t m_isConstructorCached
bool hasMultiLineInitializer() const override
bool hasCallGraph() const override
void _writeReimplementedBy(OutputList &ol) const
bool isNew() const override
void setMaxInitLines(int lines) override
bool isDocsForDefinition() const override
DString definition() const override
void setEnumClassScope(ClassDef *cd) override
void setReadAccessor(const DString &r) override
bool isUnretained() const override
bool isGettable() const override
MemberGroup * getMemberGroup() const override
bool hasUserDocumentation() const override
std::optional< ArgumentList > formalTemplateArguments() const override
std::map< const Definition *, const MemberList * > m_sectionMap
bool isEnumValue() const override
bool isObjCMethod() const override
MemberDef * memberDefinition() const override
bool m_isTypedefValCached
bool m_hasDocumentedReturnType
DString anchor() const override
StringVector m_qualifiers
void overrideCallGraph(bool e) override
void setInheritsDocsFrom(const MemberDef *md) override
bool addExample(const DString &anchor, const DString &name, const DString &file) override
Specifier virtualness(int count=0) const override
ClassDefMutable * getClassDefMutable() override
bool hasDetailedDescription() const override
void setMemberGroupId(int id) override
DString getReference() const override
bool isCSharpProperty() const override
DString m_groupFileName
void setSectionList(const Definition *container, const MemberList *sl) override
bool isRaisable() const override
void setTemplateMaster(const MemberDef *mt) override
size_t m_declColumn
std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const override
bool m_explicitInherited
const GroupDef * getGroupDef() const override
DString m_enumBaseType
bool isRelatedOrFriend() const override
void insertEnumField(MemberDef *md) override
bool isMutable() const override
bool isPublished() const override
bool isLinkableInProject() const override
bool isProtectedSettable() const override
void setMemberGroup(MemberGroup *grp) override
void setMemberDeclaration(MemberDef *md) override
void setDeclFile(const DString &df, int line, size_t column) override
bool isUNOProperty() const override
bool m_hasDocumentedParams
ModuleDef * m_moduleDef
bool m_hasReferencesRelation
void _computeIsConstructor()
size_t _countReimplementedBy() const
bool isRequired() const override
const MemberDef * m_annMemberForDetails
const MemberVector & reimplementedBy() const override
bool isStrong() const override
bool m_hasInlineSource
void moveDeclArgumentList(std::unique_ptr< ArgumentList > al) override
bool isTypeAlias() const override
void setMemberClass(ClassDef *cd) override
const MemberDef * templateMaster() const override
void setDocsForDefinition(bool b) override
const ClassDef * getCachedTypedefVal() const override
int initializerLines() const override
bool getGroupHasDocs() const override
const MemberDef * getEnumScope() const override
bool m_hasCallerGraph
bool isMaybeDefault() const override
NamespaceDef * m_nspace
bool isReimplementedBy(const ClassDef *cd) const override
StringVector getLabels(const Definition *container) const override
bool isTransient() const override
ArgumentList m_defArgList
bool m_docsForDefinition
DString m_write
MemberDef * memberDeclaration() const override
std::optional< ArgumentList > m_formalTemplateArguments
bool isInitonly() const override
bool isAddable() const override
void setWriteAccessor(const DString &w) override
bool isRelated() const override
void moveArgumentList(std::unique_ptr< ArgumentList > al) override
DString qualifiedName() const override
const ClassDef * m_cachedTypedefValue
MemberDef * m_redefines
void setCategory(ClassDef *) override
void setAnonymousMemberForDetails(const MemberDef *md) override
uint8_t m_isDestructorCached
MemberType memberType() const override
DString sourceRefName() const override
const ClassDef * m_anonymousType
Protection protection() const override
bool isConstructor() const override
void setGroupAlias(const MemberDef *md) override
void setPrototype(bool p, const DString &df, int line, size_t column) override
bool isEnumerate() const override
const ArgumentList & templateArguments() const override
bool isCopy() const override
void setType(const DString &t) override
DString declaration() const override
DString m_metaData
bool isReadonly() const override
void setTagInfo(const TagInfo *i) override
const ArgumentLists & definitionTemplateParameterLists() const override
void _writeTemplatePrefix(OutputList &ol, const Definition *def, const ArgumentList &al, bool writeReqClause=true) const
bool isStatic() const override
void writeTagFile(TextStream &, bool useQualifiedName, bool showNamespaceMembers) const override
ClassDef * m_classDef
void _writeMultiLineInitializer(OutputList &ol, const DString &scopeName) const
MemberDef * resolveAlias() override
Definition memberdef.cpp:65
bool isFinal() const override
bool isAttribute() const override
const MemberDef * m_enumScope
DString m_explicitOutputFileBase
int redefineCount() const override
void setExplicitExternal(bool b, const DString &df, int line, size_t column) override
bool isDictionary() const override
bool isSlot() const override
DString bitfieldString() const override
DString memberTypeName() const override
bool hasInlineSource() const override
void setAnchor() override
Relationship m_related
MemberGroup * m_memberGroup
const MemberDef * m_groupAlias
bool isRetain() const override
MemberVector m_redefinedBy
ClassDef * category() const override
void overrideEnumValues(bool e) override
const MemberDef * anonymousMemberForDetails() const override
bool isDocTransferDone() const override
bool isDocumentedFriendClass() const override
bool isConstEval() const override
bool hasReferencesRelation() const override
void _writeTagData(const DefType) const
void overrideReferencedByRelation(bool e) override
bool isEnumStruct() const override
bool hasEnumValues() const override
DString m_declFileName
bool isExplicit() const override
void _writeCategoryRelation(OutputList &ol) const
void setTemplateSpecialization(bool b) override
bool isTemplateSpecialization() const override
DString typeString() const override
const MemberDef * inheritsDocsFrom() const override
int getDeclLine() const override
void setTypeConstraints(const ArgumentList &al) override
void setVhdlSpecifiers(VhdlSpecifier s) override
bool isImplementation() const override
DString m_extraTypeChars
bool livesInsideEnum() const override
bool isDelete() const override
DString getCachedResolvedTypedef() const override
DString m_bitfields
DString excpString() const override
DString fieldType() const override
bool isNoExcept() const override
DString argsString() const override
bool isWeak() const override
const MemberDef * getAnonymousEnumType() const override
void setDocumentation(const DString &d, const DString &docFile, int docLine, bool stripWhiteSpace=true) override
const ModuleDef * getModuleDef() const override
void setDocTransferDone() override
bool isNoDiscard() const override
GroupDef * m_group
void incrementFlowKeyWordCount() override
const MemberDef * getGroupAlias() const override
bool isConstInit() const override
void setModuleDef(ModuleDef *mod) override
TypeSpecifier m_memSpec
DString getDeclType() const override
TypeSpecifier getMemberSpecifiers() const override
bool hasReferencedByRelation() const override
DString m_requiresClause
void makeImplementationDetail() override
Grouping::GroupPri_t getGroupPri() const override
bool isLinkable() const override
bool hasDocumentation() const override
int numberOfFlowKeyWords() const override
bool isProtectedGettable() const override
bool m_hasDetailedDescriptionCached
MemberDefImpl(const DString &defFileName, int defLine, size_t defColumn, const DString &type, const DString &name, const DString &args, const DString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const DString &metaData)
void setDefinitionTemplateParameterLists(const ArgumentLists &lists) override
ExampleList m_examples
const ArgumentList & declArgumentList() const override
void invalidateCachedArgumentTypes() override
bool _isAnonymousBitField() const
size_t getDeclColumn() const override
void detectUndocumentedParams(bool hasParamCommand, bool hasReturnCommand) const override
ClassDef * m_relatedAlso
const MemberDef * m_annEnumType
bool isWritable() const override
DString m_cachedTypedefTemplSpec
const MemberDef * m_templateMaster
bool isSealed() const override
bool isAbstract() const override
bool isPrivateSettable() const override
void setInitializer(const DString &i) override
bool isSequence() const override
void _computeLinkableInProject()
Grouping::GroupPri_t m_grouppri
void setRelatedAlso(ClassDef *cd) override
const MemberDef * m_annMemberForDecl
void addRequirementReferences(const Definition *) override
bool hasExamples() const override
void resolveUnnamedParameters(const MemberDef *md) override
void setMemberDefinition(MemberDef *md) override
bool isThreadLocal() const override
void writeMemberDocSimple(OutputList &ol, const Definition *container) const override
void setGroupDef(GroupDef *gd, Grouping::GroupPri_t pri, const DString &fileName, int startLine, bool hasDocs, MemberDef *member=nullptr) override
bool isSignal() const override
bool isMaybeVoid() const override
void init(Definition *def, const DString &t, const DString &a, const DString &e, Protection p, Specifier v, bool s, Relationship r, MemberType mt, const ArgumentList &tal, const ArgumentList &al, const DString &meta)
void _writeReimplements(OutputList &ol) const
bool isMaybeAmbiguous() const override
bool hasOneLineInitializer() const override
const MemberList * getSectionList(const Definition *) const override
bool isForeign() const override
void addQualifiers(const StringVector &qualifiers) override
void setEnumBaseType(const DString &type) override
bool isAssign() const override
bool isStrongEnumValue() const override
DString getReadAccessor() const override
void _computeIsDestructor()
bool isNotFriend() const override
const ClassDef * getClassDefOfAnonymousType() const override
void copyArgumentNames(const MemberDef *bmd) override
bool isRemovable() const override
void setExplicitInherited(bool b) override
bool isDeleted() const override
DString getGroupFileName() const override
MemberDef * m_memDef
MemberDef * m_groupMember
const DString & initializer() const override
bool isFriend() const override
DString documentation() const override
bool m_livesInsideEnum
void setArgsString(const DString &as) override
ArgumentList m_typeConstraints
ClassDef * relatedAlso() const override
DString m_initializer
void setReimplements(MemberDef *md) override
void writeLink(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool onlyText=false) const override
MemberVector m_enumFields
std::unique_ptr< IncludeInfo > m_incInfo
void writeEnumDeclaration(OutputList &typeDecl, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod) const override
bool isConstExpr() const override
bool isExternal() const override
const FileDef * getFileDef() const override
bool isNonAtomic() const override
const MemberDef * categoryRelation() const override
const MemberVector & enumFieldList() const override
const ClassDef * getClassDef() const override
void setDefinition(const DString &d) override
bool isFunctionOrSignalSlot() const override
void overrideInlineSource(bool e) override
void overrideCallerGraph(bool e) override
bool isPrivateGettable() const override
bool isEvent() const override
void setMemberSpecifiers(TypeSpecifier s) override
bool isFunctionPtr() const override
bool hasCallerGraph() const override
bool isObjCProperty() const override
void setEnumScope(MemberDef *md, bool livesInsideEnum=false) override
bool isPrototype() const override
DString requiresClause() const override
bool isTypedef() const override
void _writeGroupInclude(OutputList &ol, bool inGroup) const
FileDef * m_fileDef
bool hasDocumentedEnumValues() const override
~MemberDefImpl() override=default
void _writeEnumValues(OutputList &ol, const Definition *container, const DString &cfname, const DString &ciname, const DString &cname) const
uint8_t m_isLinkableCached
void setIncludeFile(FileDef *fd, const DString &incName, bool local, bool force) override
bool isVariable() const override
void mergeMemberSpecifiers(TypeSpecifier s) override
DString displayName(bool=true) const override
ArgumentList m_tArgList
bool isConstrained() const override
bool isReadable() const override
DString getOutputFileBase() const override
void addListReference(const Definition *) override
bool isDefault() const override
void _writeCallGraph(OutputList &ol) const
DString briefDescription(bool abbr=false) const override
bool isOverride() const override
const MemberDef * m_docProvider
bool isSettable() const override
bool isBound() const override
CodeSymbolType codeSymbolType() const override
void setBitfields(const DString &s) override
void setInbodyDocumentation(const DString &d, const DString &inbodyFile, int inbodyLine) override
virtual void setMemberDeclaration(MemberDef *md)=0
virtual void setDocTransferDone()=0
virtual void resolveUnnamedParameters(const MemberDef *md)=0
virtual void overrideReferencesRelation(bool e)=0
virtual void overrideReferencedByRelation(bool e)=0
virtual void setDocsForDefinition(bool b)=0
virtual void overrideCallGraph(bool e)=0
virtual void overrideInlineSource(bool e)=0
virtual void overrideEnumValues(bool e)=0
virtual void mergeMemberSpecifiers(TypeSpecifier s)=0
virtual void addQualifiers(const StringVector &qualifiers)=0
virtual void moveDeclArgumentList(std::unique_ptr< ArgumentList > al)=0
virtual void overrideCallerGraph(bool e)=0
virtual void setMemberDefinition(MemberDef *md)=0
virtual void moveArgumentList(std::unique_ptr< ArgumentList > al)=0
virtual void insertReimplementedBy(MemberDef *md)=0
virtual void setGroupDef(GroupDef *gd, Grouping::GroupPri_t pri, const DString &fileName, int startLine, bool hasDocs, MemberDef *member=nullptr)=0
A class representing a group of members.
Definition membergroup.h:42
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:126
A vector of MemberDef object.
Definition memberlist.h:36
iterator end() noexcept
Definition memberlist.h:57
bool contains(const MemberDef *md) const
Definition memberlist.h:90
void inSort(MemberDef *md)
Definition memberlist.h:81
iterator begin() noexcept
Definition memberlist.h:55
void push_back(const T &value)
Definition memberlist.h:49
An abstract interface of a namespace symbol.
virtual DString compoundTypeString() const =0
void startCodeFragment(const DString &style)
Definition outputlist.h:276
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:311
void writeDoc(const IDocNodeAST *ast, const Definition *ctx, const MemberDef *md, int sectionLevel=-1)
Definition outputlist.h:379
void endIndent()
Definition outputlist.h:580
void startMemberDeclaration()
Definition outputlist.h:565
void parseText(const DString &textStr)
void endDescTableRow()
Definition outputlist.h:630
void startMemberDocName(bool align)
Definition outputlist.h:676
void endParameterExtra(bool last, bool one, bool bracket)
Definition outputlist.h:690
void writeChar(char c)
Definition outputlist.h:525
void disable(OutputType o)
void startParagraph(const DString &classDef=DString())
Definition outputlist.h:403
void writeObjectLink(const DString &ref, const DString &file, const DString &anchor, const DString &name)
Definition outputlist.h:435
void endMemberDocName()
Definition outputlist.h:678
void endMemberDoc(bool hasArgs)
Definition outputlist.h:531
void startDescTableInit()
Definition outputlist.h:636
void startCallGraph()
Definition outputlist.h:652
void addIndexItem(const DString &s1, const DString &s2)
Definition outputlist.h:586
void endDescTable()
Definition outputlist.h:626
void startParameterExtra()
Definition outputlist.h:688
void endPageRef(const DString &c, const DString &a)
Definition outputlist.h:596
const OutputCodeList & codeGenerators() const
Definition outputlist.h:354
void startParameterList(bool openBracket)
Definition outputlist.h:696
void writeLatexSpacing()
Definition outputlist.h:541
void enable(OutputType o)
void endInlineMemberType()
Definition outputlist.h:724
void endMemberDescription()
Definition outputlist.h:563
void endMemberDeclaration(const DString &anchor, const DString &inheritId)
Definition outputlist.h:567
void startInlineMemberType()
Definition outputlist.h:722
void docify(const DString &s)
Definition outputlist.h:433
void startInlineMemberDoc()
Definition outputlist.h:730
void endMemberTemplateParams(const DString &anchor, const DString &inheritId)
Definition outputlist.h:495
void lineBreak(const DString &style=DString())
Definition outputlist.h:555
void startMemberDoc(const DString &clName, const DString &memName, const DString &anchor, const DString &title, int memCount, int memTotal, bool showInline)
Definition outputlist.h:527
void endDescTableTitle()
Definition outputlist.h:634
void insertMemberAlign(bool templ=false)
Definition outputlist.h:513
void startIndent()
Definition outputlist.h:578
void writeString(const DString &text)
Definition outputlist.h:407
void endDescForItem()
Definition outputlist.h:545
void endExamples()
Definition outputlist.h:576
void endDoxyAnchor(const DString &fn, const DString &anchor)
Definition outputlist.h:537
void startDescTable(const DString &title, const bool hasInits)
Definition outputlist.h:624
void endParagraph()
Definition outputlist.h:405
void endDescTableData()
Definition outputlist.h:642
void disableAll()
void startDescTableTitle()
Definition outputlist.h:632
void startPageRef()
Definition outputlist.h:594
void startExamples()
Definition outputlist.h:574
void endInlineMemberDoc()
Definition outputlist.h:732
void endMemberDocPrefixItem()
Definition outputlist.h:674
void startParameterDefVal(const char *separator)
Definition outputlist.h:692
void startAnonTypeScope(int i1)
Definition outputlist.h:485
void addLabel(const DString &fName, const DString &anchor)
Definition outputlist.h:539
void startBold()
Definition outputlist.h:557
void endMemberItem(OutputGenerator::MemberItemType type)
Definition outputlist.h:491
void startTypewriter()
Definition outputlist.h:445
void startDescTableData()
Definition outputlist.h:640
void pushGeneratorState()
void startDescForItem()
Definition outputlist.h:543
void endParameterDefVal()
Definition outputlist.h:694
void disableAllBut(OutputType o)
void exceptionEntry(const DString &prefix, bool closeBracket)
Definition outputlist.h:700
void endParameterName()
Definition outputlist.h:686
void popGeneratorState()
void endBold()
Definition outputlist.h:559
void writeLabel(const DString &l, bool isLast)
Definition outputlist.h:736
void endLabels()
Definition outputlist.h:738
void startMemberItem(const DString &anchor, OutputGenerator::MemberItemType type, const DString &id=DString())
Definition outputlist.h:489
void startMemberDescription(const DString &anchor, const DString &inheritId=DString(), bool typ=false)
Definition outputlist.h:561
void endParameterList()
Definition outputlist.h:698
void endCallGraph(DotCallGraph &g)
Definition outputlist.h:654
void startInlineMemberName()
Definition outputlist.h:726
void generateDoc(const DString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const DString &docStr, const DocOptions &options)
void startLabels()
Definition outputlist.h:734
void endParameterType()
Definition outputlist.h:682
void startMemberDocPrefixItem()
Definition outputlist.h:672
void endAnonTypeScope(int i1)
Definition outputlist.h:487
void startParameterName(bool one)
Definition outputlist.h:684
void enableAll()
void startParameterType(bool first, const DString &key)
Definition outputlist.h:680
void endTypewriter()
Definition outputlist.h:447
void endInlineMemberName()
Definition outputlist.h:728
void writeNonBreakableSpace(int num)
Definition outputlist.h:622
void startDoxyAnchor(const DString &fName, const DString &manName, const DString &anchor, const DString &name, const DString &args)
Definition outputlist.h:533
void endDescTableInit()
Definition outputlist.h:638
void startDescTableRow()
Definition outputlist.h:628
void startMemberTemplateParams()
Definition outputlist.h:493
std::unique_ptr< CodeParserInterface > getCodeParser(const DString &extension)
Gets the interface to the parser associated with a given extension.
Definition parserintf.h:253
static RequirementManager & instance()
void addRequirementRefsForSymbol(const Definition *symbol)
This struct is used to capture the tag file information for an Entry.
Definition entry.h:101
DString tagName
Definition entry.h:103
DString anchor
Definition entry.h:105
DString fileName
Definition entry.h:104
Implements TextGeneratorIntf for an OutputDocInterface stream.
Definition outputlist.h:786
Text streaming class that buffers data.
Definition textstream.h:36
virtual DString trProvidedByCategory()=0
virtual DString trReimplementedFromList(int numEntries)=0
virtual DString trDefineValue()=0
virtual DString trSubprogram(bool first_capital, bool singular)=0
virtual DString trImplementedInList(int numEntries)=0
virtual DString trInitialValue()=0
virtual DString trImplementedFromList(int numEntries)=0
virtual DString trVhdlType(VhdlSpecifier type, bool single)=0
virtual DString trPageAbbreviation()=0
virtual DString trReimplementedInList(int numEntries)=0
virtual DString trExtendsClass()=0
virtual DString trCallerGraph()=0
virtual DString trMember(bool first_capital, bool singular)=0
virtual DString trEnumerationValues()=0
virtual DString trCallGraph()=0
virtual DString trGlobal(bool first_capital, bool singular)=0
Wrapper class for a number of boolean properties.
Definition types.h:696
static bool writeVHDLTypeDocumentation(const MemberDef *mdef, const Definition *d, OutputList &ol)
static bool isMisc(const MemberDef *mdef)
static void writeSource(const MemberDef *mdef, OutputList &ol, const DString &cname)
ClassDefMutable * toClassDefMutable(Definition *d)
ClassDef * getClass(const DString &n)
ClassDef * toClassDef(Definition *d)
Class representing a regular expression.
Definition regex.h:39
Object representing the matching results.
Definition regex.h:160
SubMatch prefix() const
Return the part of the string before the match.
Definition regex.h:175
size_t position() const
Returns the position of the match or std::string::npos if no position is set.
Definition regex.h:166
SubMatch suffix() const
Return the part of the string after the match.
Definition regex.h:178
size_t length() const
Returns the position of the match or std::string::npos if no length is set.
Definition regex.h:169
std::string str() const
Returns the matching part as a string.
Definition regex.h:138
#define Config_getInt(name)
Definition config.h:34
#define Config_getList(name)
Definition config.h:38
#define Config_getBool(name)
Definition config.h:33
#define NON_COPYABLE(cls)
Macro to help implementing the rule of 5 for a non-copyable & movable class.
Definition construct.h:37
std::vector< std::string > StringVector
Definition containers.h:33
std::unique_ptr< ArgumentList > stringToArgumentList(SrcLangExt lang, const DString &argsString, DString *extraTypeChars=nullptr)
Definition defargs.l:822
Definition * toDefinition(DefinitionMutable *dm)
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:54
#define AUTO_TRACE(...)
Definition docnode.cpp:53
IDocParserPtr createDocParser()
factory function to create a parser
Definition docparser.cpp:59
void docFindSections(const DString &input, const Definition *d, const DString &fileName)
IDocNodeASTPtr validatingParseDoc(IDocParser &parserIntf, const DString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const DString &input, const DocOptions &options)
DString substitute(const DString &s, const DString &src, const DString &dst)
substitute all occurrences of src in s by dst
Definition dstring.cpp:485
bool isId(char c)
Returns true if c is a valid character for an identifier.
Definition dstring.h:895
bool disspace(char c)
Definition dstring.h:62
DString includeClose(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:82
DString includeOpen(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:69
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:2054
DString includeStatement(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:52
@ IncludeLocal
Definition filedef.h:47
@ IncludeSystem
Definition filedef.h:46
GroupDef * toGroupDef(Definition *d)
Translator * theTranslator
Definition language.cpp:76
void linkifyText(const TextGeneratorIntf &out, const DString &text, const LinkifyTextOptions &options)
DString md5str(const std::string_view &str)
Definition md5hash.h:33
static DString simplifyTypeForTable(const DString &s)
static DString addTemplateNames(const DString &s, const DString &n, const DString &t)
static void writeExceptionListImpl(OutputList &ol, const ClassDef *cd, const MemberDef *md, DString const &exception)
static void writeExceptionList(OutputList &ol, const ClassDef *cd, const MemberDef *md)
static void writePageRef(OutputList &ol, const DString &cn, const DString &mn)
static DString combineArgsAndException(DString args, DString exception)
static bool writeDefArgumentList(OutputList &ol, const Definition *scope, const MemberDef *md)
static std::mutex g_hasDetailedDescriptionMutex
std::unique_ptr< MemberDef > createMemberDef(const DString &defFileName, int defLine, size_t defColumn, const DString &type, const DString &name, const DString &args, const DString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const DString &metaData)
Factory method to create a new instance of a MemberDef.
static std::mutex g_docCrossReferenceMutex
std::unique_ptr< MemberDef > createMemberDefAlias(const Definition *newScope, const MemberDef *aliasMd)
static void invalidateCachedTypesInArgumentList(ArgumentList &al)
static std::mutex g_detectUndocumentedParamsMutex
static void transferArgumentDocumentation(ArgumentList &decAl, ArgumentList &defAl)
void addDocCrossReference(const MemberDef *s, const MemberDef *d)
MemberDefMutable * toMemberDefMutable(Definition *d)
void mergeMemberOverrideOptions(MemberDefMutable *md1, MemberDefMutable *md2)
static DString stripTrailingReturn(const DString &trailRet)
void combineDeclarationAndDefinition(MemberDefMutable *mdec, MemberDefMutable *mdef)
static bool hasParamCommand(const DString &doc)
MemberDef * toMemberDef(Definition *d)
static const reg::Ex reAnonymous(R"([\w:@]*@\d+)")
#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 ASSERT(x)
Definition message.h:142
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
ModuleDef * toModuleDef(Definition *d)
NamespaceDef * toNamespaceDef(Definition *d)
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:850
void addRefItem(const RefItemVector &sli, const DString &key, const DString &prefix, const DString &name, const DString &title, const DString &args, const Definition *scope)
Definition reflist.h:136
std::vector< RefItem * > RefItemVector
Definition reflist.h:134
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:75
Options to configure the code parser.
Definition parserintf.h:77
Helper class to pass options when calling OutputList::generateDoc().
Definition docoptions.h:24
Data associated with an example.
Definition example.h:29
GroupPri_t
Grouping priority.
Definition types.h:230
@ GROUPING_AUTO_DEF
membership in group was defined via @defgroup
Definition types.h:234
LinkifyTextOptions & setScope(const Definition *scope)
Definition linkifytext.h:60
LinkifyTextOptions & setSelf(const Definition *self)
Definition linkifytext.h:66
LinkifyTextOptions & setFileScope(const FileDef *fileScope)
Definition linkifytext.h:63
CodeSymbolType
Definition types.h:481
MemberType
Definition types.h:571
MemberListContainer
Definition types.h:472
bool isTypeAClassFriend(const DString &type)
Definition types.h:923
Protection
Definition types.h:32
SrcLangExt
Definition types.h:207
Relationship
Definition types.h:167
Specifier
Definition types.h:80
VhdlSpecifier
Definition types.h:772
DString stripExtension(const DString &fName)
Definition util.cpp:3964
DString substituteTemplateArgumentsInString(const DString &nm, const ArgumentList &formalArgs, const ArgumentList *actualArgs)
Definition util.cpp:3533
DString inlineArgListToDoc(const ArgumentList &al)
Definition util.cpp:4878
bool protectionLevelVisible(Protection prot)
Definition util.cpp:4684
DString stripFromIncludePath(const DString &path)
Definition util.cpp:227
DString detab(const DString &s, size_t &refIndent)
Definition util.cpp:5207
void stripIndentationVerbatim(DString &doc, size_t indentationLevel, bool skipFirstLine)
Definition util.cpp:4785
void writeTypeConstraints(OutputList &ol, const Definition *d, const ArgumentList &al)
Definition util.cpp:4292
DString removeRedundantWhiteSpace(const DString &s)
Definition util.cpp:427
DString tempArgListToString(const ArgumentList &al, SrcLangExt lang, bool includeDefault)
Definition util.cpp:908
SrcLangExt getLanguageFromFileName(const DString &fileName, SrcLangExt defLang)
Definition util.cpp:4177
bool matchArguments2(const Definition *srcScope, const FileDef *srcFileScope, const DString &srcReturnType, const ArgumentList *srcAl, const Definition *dstScope, const FileDef *dstFileScope, const DString &dstReturnType, const ArgumentList *dstAl, bool checkCV, SrcLangExt lang)
Definition util.cpp:1597
void addHtmlExtensionIfMissing(DString &fName)
Definition util.cpp:3940
DString convertToXML(const DString &s, bool keepEntities, const bool citeEntry)
Definition util.cpp:3241
DString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Definition util.cpp:4642
DString removeAnonymousScopes(const DString &str)
Definition util.cpp:98
void writeMarkerList(OutputList &ol, const std::string &markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)
Definition util.cpp:758
DString inlineTemplateArgListToDoc(const ArgumentList &al)
Definition util.cpp:837
void writeExamples(OutputList &ol, const ExampleList &list)
Definition util.cpp:809
A bunch of utility functions.