diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/classdef.cpp | 6 | ||||
| -rw-r--r-- | src/classdef.h | 1 | ||||
| -rw-r--r-- | src/context.cpp | 1006 | ||||
| -rw-r--r-- | src/context.h | 48 | ||||
| -rw-r--r-- | src/definition.cpp | 11 | ||||
| -rw-r--r-- | src/definition.h | 9 | ||||
| -rw-r--r-- | src/htmlgen.h | 2 | ||||
| -rw-r--r-- | src/markdown.cpp | 12 | ||||
| -rw-r--r-- | src/memberdef.cpp | 51 | ||||
| -rw-r--r-- | src/memberdef.h | 8 | ||||
| -rw-r--r-- | src/membergroup.h | 4 | ||||
| -rw-r--r-- | src/portable.cpp | 6 | ||||
| -rw-r--r-- | src/template.cpp | 24 | ||||
| -rw-r--r-- | src/template.h | 82 | ||||
| -rw-r--r-- | src/util.cpp | 23 | ||||
| -rw-r--r-- | src/util.h | 2 |
16 files changed, 1077 insertions, 218 deletions
diff --git a/src/classdef.cpp b/src/classdef.cpp index 25c6b58..53eabc2 100644 --- a/src/classdef.cpp +++ b/src/classdef.cpp @@ -4769,3 +4769,9 @@ const ExampleSDict *ClassDef::exampleList() const { return m_impl->exampleSDict; } + +bool ClassDef::subGrouping() const +{ + return m_impl->subGrouping; +} + diff --git a/src/classdef.h b/src/classdef.h index eb36383..f6d594c 100644 --- a/src/classdef.h +++ b/src/classdef.h @@ -317,6 +317,7 @@ class ClassDef : public Definition const ExampleSDict *exampleList() const; bool hasExamples() const; QCString getMemberListFileName() const; + bool subGrouping() const; //----------------------------------------------------------------------------------- // --- setters ---- diff --git a/src/context.cpp b/src/context.cpp index 1881147..7e14c8b 100644 --- a/src/context.cpp +++ b/src/context.cpp @@ -21,6 +21,7 @@ #include "diagram.h" #include "example.h" #include "membername.h" +#include "parserintf.h" struct ContextGlobals { @@ -328,31 +329,7 @@ class TranslateContext::Private : public PropertyMapper { public: - static TemplateVariant generatedAtFunc(const void *obj,const QValueList<TemplateVariant> &args) - { - return ((TranslateContext::Private*)obj)->generatedAt(args); - } - static TemplateVariant inheritanceDiagramForFunc(const void *obj,const QValueList<TemplateVariant> &args) - { - return ((TranslateContext::Private*)obj)->inheritanceDiagramFor(args); - } - static TemplateVariant inheritsListFunc(const void *obj,const QValueList<TemplateVariant> &args) - { - return ((TranslateContext::Private*)obj)->inheritsList(args); - } - static TemplateVariant inheritedByListFunc(const void *obj,const QValueList<TemplateVariant> &args) - { - return ((TranslateContext::Private*)obj)->inheritedByList(args); - } - static TemplateVariant collaborationDiagramForFunc(const void *obj,const QValueList<TemplateVariant> &args) - { - return ((TranslateContext::Private*)obj)->collaborationDiagramFor(args); - } - static TemplateVariant writeListFunc(const void *obj,const QValueList<TemplateVariant> &args) - { - return ((TranslateContext::Private*)obj)->writeList(args); - } - TemplateVariant generatedAt(const QValueList<TemplateVariant> &args) const + TemplateVariant handleGeneratedAt(const QValueList<TemplateVariant> &args) const { if (args.count()==2) { @@ -364,7 +341,7 @@ class TranslateContext::Private : public PropertyMapper } return TemplateVariant(); } - TemplateVariant inheritanceDiagramFor(const QValueList<TemplateVariant> &args) const + TemplateVariant handleInheritanceDiagramFor(const QValueList<TemplateVariant> &args) const { if (args.count()==1) { @@ -376,7 +353,7 @@ class TranslateContext::Private : public PropertyMapper } return TemplateVariant(); } - TemplateVariant collaborationDiagramFor(const QValueList<TemplateVariant> &args) const + TemplateVariant handleCollaborationDiagramFor(const QValueList<TemplateVariant> &args) const { if (args.count()==1) { @@ -388,7 +365,7 @@ class TranslateContext::Private : public PropertyMapper } return TemplateVariant(); } - TemplateVariant inheritsList(const QValueList<TemplateVariant> &args) const + TemplateVariant handleInheritsList(const QValueList<TemplateVariant> &args) const { if (args.count()==1) { @@ -400,7 +377,7 @@ class TranslateContext::Private : public PropertyMapper } return TemplateVariant(); } - QCString inheritedByList(const QValueList<TemplateVariant> &args) const + TemplateVariant handleInheritedByList(const QValueList<TemplateVariant> &args) const { if (args.count()==1) { @@ -410,9 +387,9 @@ class TranslateContext::Private : public PropertyMapper { err("tr.inheritedByList should take one integer parameter, got %d!\n",args.count()); } - return QCString(); + return TemplateVariant(); } - QCString writeList(const QValueList<TemplateVariant> &args) const + TemplateVariant handleWriteList(const QValueList<TemplateVariant> &args) const { if (args.count()==1) { @@ -422,7 +399,55 @@ class TranslateContext::Private : public PropertyMapper { err("tr.*List should take one integer parameter, got %d!\n",args.count()); } - return QCString(); + return TemplateVariant(); + } + TemplateVariant handleImplementedBy(const QValueList<TemplateVariant> &args) const + { + if (args.count()==1) + { + return theTranslator->trImplementedInList(args[0].toInt()); + } + else + { + err("tr.implementedBy should take one integer parameter, got %d!\n",args.count()); + } + return TemplateVariant(); + } + TemplateVariant handleReimplementedBy(const QValueList<TemplateVariant> &args) const + { + if (args.count()==1) + { + return theTranslator->trReimplementedInList(args[0].toInt()); + } + else + { + err("tr.reimplementedBy should take one integer parameter, got %d!\n",args.count()); + } + return TemplateVariant(); + } + TemplateVariant handleSourceRefs(const QValueList<TemplateVariant> &args) const + { + if (args.count()==1) + { + return theTranslator->trReferences()+" "+theTranslator->trWriteList(args[0].toInt())+"."; + } + else + { + err("tr.sourceRefs should take one integer parameter, got %d\n",args.count()); + } + return TemplateVariant(); + } + TemplateVariant handleSourceRefBys(const QValueList<TemplateVariant> &args) const + { + if (args.count()==1) + { + return theTranslator->trReferencedBy()+" "+theTranslator->trWriteList(args[0].toInt())+"."; + } + else + { + err("tr.sourceRefBys should take one integer parameter, got %d\n",args.count()); + } + return TemplateVariant(); } @@ -433,15 +458,15 @@ class TranslateContext::Private : public PropertyMapper } TemplateVariant generatedAt() const { - return TemplateVariant(this,&Private::generatedAtFunc); + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleGeneratedAt>(this); } TemplateVariant inheritanceDiagramFor() const { - return TemplateVariant(this,&Private::inheritanceDiagramForFunc); + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleInheritanceDiagramFor>(this); } TemplateVariant collaborationDiagramFor() const { - return TemplateVariant(this,&Private::collaborationDiagramForFunc); + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleCollaborationDiagramFor>(this); } TemplateVariant search() const { @@ -554,11 +579,11 @@ class TranslateContext::Private : public PropertyMapper } TemplateVariant inheritsList() const { - return TemplateVariant(this,&Private::inheritsListFunc); + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleInheritsList>(this); } TemplateVariant inheritedByList() const { - return TemplateVariant(this,&Private::inheritedByListFunc); + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleInheritedByList>(this); } TemplateVariant definedAtLineInSourceFile() const { @@ -570,7 +595,7 @@ class TranslateContext::Private : public PropertyMapper } TemplateVariant exampleList() const { - return TemplateVariant(this,&Private::writeListFunc); + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleWriteList>(this); } TemplateVariant listOfAllMembers() const { @@ -588,6 +613,50 @@ class TranslateContext::Private : public PropertyMapper { return theTranslator->trIncludingInheritedMembers(); } + TemplateVariant defineValue() const + { + return theTranslator->trDefineValue(); + } + TemplateVariant initialValue() const + { + return theTranslator->trInitialValue(); + } + TemplateVariant enumerationValues() const + { + return theTranslator->trEnumerationValues(); + } + TemplateVariant implements() const + { + return theTranslator->trImplementedFromList(1); + } + TemplateVariant reimplements() const + { + return theTranslator->trReimplementedFromList(1); + } + TemplateVariant implementedBy() const + { + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleImplementedBy>(this); + } + TemplateVariant reimplementedBy() const + { + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleReimplementedBy>(this); + } + TemplateVariant sourceRefs() const + { + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleSourceRefs>(this); + } + TemplateVariant sourceRefBys() const + { + return TemplateVariant::Delegate::fromMethod<Private,&Private::handleSourceRefBys>(this); + } + TemplateVariant callGraph() const + { + return theTranslator->trCallGraph(); + } + TemplateVariant callerGraph() const + { + return theTranslator->trCallerGraph(); + } Private() { //%% string generatedBy @@ -654,6 +723,28 @@ class TranslateContext::Private : public PropertyMapper addProperty("theListOfAllMembers",this,&Private::theListOfAllMembers); //%% string incInheritedMembers addProperty("incInheritedMembers",this,&Private::incInheritedMembers); + //%% string defineValue + addProperty("defineValue", this,&Private::defineValue); + //%% string initialValue + addProperty("initialValue", this,&Private::initialValue); + //%% string enumerationValues + addProperty("enumerationValues", this,&Private::enumerationValues); + //%% markerstring implements + addProperty("implements", this,&Private::implements); + //%% markerstring reimplements + addProperty("reimplements", this,&Private::reimplements); + //%% markerstring implementedBy + addProperty("implementedBy", this,&Private::implementedBy); + //%% markerstring reimplementedBy + addProperty("reimplementedBy", this,&Private::reimplementedBy); + //%% markerstring sourceRefs + addProperty("sourceRefs", this,&Private::sourceRefs); + //%% markerstring sourceRefBys + addProperty("sourceRefBys", this,&Private::sourceRefBys); + //%% string callGraph + addProperty("callGraph", this,&Private::callGraph); + //%% string callerGraph + addProperty("callerGraph", this,&Private::callerGraph); m_javaOpt = Config_getBool("OPTIMIZE_OUTPUT_JAVA"); m_fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN"); @@ -703,6 +794,19 @@ static TemplateVariant parseDoc(Definition *def,const QCString &file,int line, return result; } +static TemplateVariant parseCode(MemberDef *md,const QCString &scopeName,const QCString &relPath, + const QCString &code,int startLine=-1,int endLine=-1,bool showLineNumbers=FALSE) +{ + ParserInterface *pIntf = Doxygen::parserManager->getParser(md->getDefFileExtension()); + pIntf->resetCodeParserState(); + QGString s; + FTextStream t(&s); + HtmlCodeGenerator codeGen(t,relPath); + pIntf->parseCode(codeGen,scopeName,code,md->getLanguage(),FALSE,0,md->getBodyDef(), + startLine,endLine,TRUE,md,showLineNumbers,md); + return TemplateVariant(s.data(),TRUE); +} + //------------------------------------------------------------------------ //%% struct Symbol: shared info for all symbols @@ -727,6 +831,8 @@ class DefinitionContext : public PropertyMapper addProperty("details",this,&DefinitionContext::details); //%% string brief: the brief description for this symbol addProperty("brief",this,&DefinitionContext::brief); + //%% string inbodyDocs: the documentation found in the body + addProperty("inbodyDocs",this,&DefinitionContext::inbodyDocs); //%% string sourceFileName: the file name of the source file (without extension) addProperty("sourceFileName",this,&DefinitionContext::sourceFileName); //%% bool isLinkable: can the symbol be linked to? @@ -745,7 +851,7 @@ class DefinitionContext : public PropertyMapper m_sourceDef.append(&m_lineLink); m_sourceDef.append(&m_fileLink); m_lineLink.set("text",m_def->getStartBodyLine()); - m_lineLink.set("isLinkable",m_def->isLinkable()); + m_lineLink.set("isLinkable",TRUE); m_lineLink.set("fileName",m_def->getSourceFileBase()); m_lineLink.set("anchor",m_def->getSourceAnchor()); if (m_def->definitionType()==Definition::TypeFile) @@ -760,7 +866,7 @@ class DefinitionContext : public PropertyMapper { m_fileLink.set("text",name()); } - m_fileLink.set("isLinkable",m_def->isLinkable()); + m_fileLink.set("isLinkable",TRUE); m_fileLink.set("fileName",m_def->getSourceFileBase()); m_fileLink.set("anchor",QCString()); } @@ -827,6 +933,22 @@ class DefinitionContext : public PropertyMapper } return *m_cache.brief; } + TemplateVariant inbodyDocs() const + { + if (!m_cache.inbodyDocs) + { + if (!m_def->inbodyDocumentation().isEmpty()) + { + m_cache.inbodyDocs.reset(new TemplateVariant(parseDoc(m_def,m_def->inbodyFile(),m_def->inbodyLine(), + relPathAsString(),m_def->inbodyDocumentation(),FALSE))); + } + else + { + m_cache.inbodyDocs.reset(new TemplateVariant("")); + } + } + return *m_cache.inbodyDocs; + } TemplateVariant dynSectionId() const { return g_globals.dynSectionId; @@ -873,6 +995,7 @@ class DefinitionContext : public PropertyMapper { ScopedPtr<TemplateVariant> details; ScopedPtr<TemplateVariant> brief; + ScopedPtr<TemplateVariant> inbodyDocs; }; mutable Cachable m_cache; TemplateList m_sourceDef; @@ -954,7 +1077,7 @@ TemplateVariant IncludeInfoContext::get(const char *n) const class ClassContext::Private : public DefinitionContext<ClassContext::Private> { public: - Private(ClassDef *cd) : DefinitionContext(cd) , + Private(ClassDef *cd) : DefinitionContext<ClassContext::Private>(cd) , m_classDef(cd), m_usedFiles(cd), m_includeInfo(cd ? cd->includeInfo() : 0, cd ? cd->getLanguage() : SrcLangExt_Unknown) { @@ -1001,12 +1124,17 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> addProperty("properties", this,&Private::properties); addProperty("events", this,&Private::events); addProperty("friends", this,&Private::friends); - addProperty("relatedDecls", this,&Private::relatedDecls); - - addProperty("typedefs", this,&Private::typedefs); - addProperty("methods", this,&Private::methods); - addProperty("relatedDefs", this,&Private::relatedDefs); - + addProperty("related", this,&Private::related); + addProperty("detailedTypedefs", this,&Private::detailedTypedefs); + addProperty("detailedEnums", this,&Private::detailedEnums); + addProperty("detailedServices", this,&Private::detailedServices); + addProperty("detailedInterfaces", this,&Private::detailedInterfaces); + addProperty("detailedConstructors", this,&Private::detailedConstructors); + addProperty("detailedMethods", this,&Private::detailedMethods); + addProperty("detailedRelated", this,&Private::detailedRelated); + addProperty("detailedVariables", this,&Private::detailedVariables); + addProperty("detailedProperties", this,&Private::detailedProperties); + addProperty("detailedEvents", this,&Private::detailedEvents); addProperty("nestedClasses", this,&Private::nestedClasses); addProperty("compoundType", this,&Private::compoundType); addProperty("templateDecls", this,&Private::templateDecls); @@ -1014,6 +1142,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> addProperty("examples", this,&Private::examples); addProperty("allMembersList", this,&Private::allMembersList); addProperty("allMembersFileName", this,&Private::allMembersFileName); + addProperty("memberGroups", this,&Private::memberGroups); } TemplateVariant title() const { @@ -1176,7 +1305,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> MemberList *ml = m_classDef->getMemberList(type); if (ml) { - list.reset(new MemberListInfoContext(ml,title)); + list.reset(new MemberListInfoContext(m_classDef,relPathAsString(),ml,title)); } } if (list) @@ -1308,21 +1437,49 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> { return getMemberList(m_cache.friends,MemberListType_friends,theTranslator->trFriends()); } - TemplateVariant relatedDecls() const + TemplateVariant related() const + { + return getMemberList(m_cache.related,MemberListType_related,theTranslator->trRelatedFunctions()); + } + TemplateVariant detailedTypedefs() const + { + return getMemberList(m_cache.detailedTypedefs,MemberListType_typedefMembers,theTranslator->trMemberTypedefDocumentation()); + } + TemplateVariant detailedEnums() const + { + return getMemberList(m_cache.detailedEnums,MemberListType_enumMembers,theTranslator->trMemberEnumerationDocumentation()); + } + TemplateVariant detailedServices() const + { + return getMemberList(m_cache.detailedServices,MemberListType_serviceMembers,theTranslator->trServices()); + } + TemplateVariant detailedInterfaces() const + { + return getMemberList(m_cache.detailedInterfaces,MemberListType_interfaceMembers,theTranslator->trInterfaces()); + } + TemplateVariant detailedConstructors() const + { + return getMemberList(m_cache.detailedConstructors,MemberListType_constructors,theTranslator->trConstructorDocumentation()); + } + TemplateVariant detailedMethods() const + { + return getMemberList(m_cache.detailedMethods,MemberListType_functionMembers,theTranslator->trMemberFunctionDocumentation()); + } + TemplateVariant detailedRelated() const { - return getMemberList(m_cache.relatedDecls,MemberListType_related,theTranslator->trRelatedFunctions()); + return getMemberList(m_cache.detailedRelated,MemberListType_relatedMembers,theTranslator->trRelatedFunctionDocumentation()); } - TemplateVariant typedefs() const + TemplateVariant detailedVariables() const { - return getMemberList(m_cache.typedefs,MemberListType_typedefMembers,theTranslator->trMemberTypedefDocumentation()); + return getMemberList(m_cache.detailedVariables,MemberListType_variableMembers,theTranslator->trMemberDataDocumentation()); } - TemplateVariant methods() const + TemplateVariant detailedProperties() const { - return getMemberList(m_cache.methods,MemberListType_functionMembers,theTranslator->trMemberFunctionDocumentation()); + return getMemberList(m_cache.detailedProperties,MemberListType_propertyMembers,theTranslator->trPropertyDocumentation()); } - TemplateVariant relatedDefs() const + TemplateVariant detailedEvents() const { - return getMemberList(m_cache.relatedDefs,MemberListType_relatedMembers,theTranslator->trRelatedFunctionDocumentation()); + return getMemberList(m_cache.detailedEvents,MemberListType_eventMembers,theTranslator->trEventDocumentation()); } TemplateVariant nestedClasses() const { @@ -1331,9 +1488,9 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> static bool extractLocalClasses = Config_getBool("EXTRACT_LOCAL_CLASSES"); if (!m_cache.nestedClasses) { + NestedClassListContext *classList = new NestedClassListContext; if (m_classDef->getClassSDict()) { - NestedClassListContext *classList = new NestedClassListContext; ClassSDict::Iterator sdi(*m_classDef->getClassSDict()); ClassDef *cd; for (sdi.toFirst();(cd=sdi.current());++sdi) @@ -1348,17 +1505,10 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> classList->append(cd); } } - m_cache.nestedClasses.reset(classList); } + m_cache.nestedClasses.reset(classList); } - if (m_cache.nestedClasses) - { - return m_cache.nestedClasses.get(); - } - else - { - return TemplateVariant(FALSE); - } + return m_cache.nestedClasses.get(); } TemplateVariant compoundType() const { @@ -1410,14 +1560,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> addTemplateDecls(m_classDef,tl); m_cache.templateDecls.reset(tl); } - if (m_cache.templateDecls) - { - return m_cache.templateDecls.get(); - } - else - { - return TemplateVariant(FALSE); - } + return m_cache.templateDecls.get(); } TemplateVariant typeConstraints() const { @@ -1425,14 +1568,11 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> { m_cache.typeConstraints.reset(new ArgumentListContext(m_classDef->typeConstraints(),m_classDef,relPathAsString())); } - if (m_cache.typeConstraints) - { - return m_cache.typeConstraints.get(); - } else { - return TemplateVariant(FALSE); + m_cache.typeConstraints.reset(new ArgumentListContext); } + return m_cache.typeConstraints.get(); } TemplateVariant examples() const { @@ -1442,14 +1582,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> addExamples(exampleList); m_cache.examples.reset(exampleList); } - if (m_cache.examples) - { - return m_cache.examples.get(); - } - else - { - return TemplateVariant(FALSE); - } + return m_cache.examples.get(); } TemplateVariant allMembersList() const { @@ -1458,19 +1591,31 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> AllMembersListContext *ml = new AllMembersListContext(m_classDef->memberNameInfoSDict()); m_cache.allMembersList.reset(ml); } - if (m_cache.allMembersList) - { - return m_cache.allMembersList.get(); - } else { - return TemplateVariant(FALSE); + m_cache.allMembersList.reset(new AllMembersListContext); } + return m_cache.allMembersList.get(); } TemplateVariant allMembersFileName() const { return m_classDef->getMemberListFileName(); } + TemplateVariant memberGroups() const + { + if (!m_cache.memberGroups) + { + if (m_classDef->getMemberGroupSDict()) + { + m_cache.memberGroups.reset(new MemberGroupListContext(m_classDef,relPathAsString(),m_classDef->getMemberGroupSDict(),m_classDef->subGrouping())); + } + else + { + m_cache.memberGroups.reset(new MemberGroupListContext); + } + } + return m_cache.memberGroups.get(); + } private: ClassDef *m_classDef; @@ -1517,10 +1662,18 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private> ScopedPtr<MemberListInfoContext> properties; ScopedPtr<MemberListInfoContext> events; ScopedPtr<MemberListInfoContext> friends; - ScopedPtr<MemberListInfoContext> relatedDecls; - ScopedPtr<MemberListInfoContext> typedefs; - ScopedPtr<MemberListInfoContext> methods; - ScopedPtr<MemberListInfoContext> relatedDefs; + ScopedPtr<MemberListInfoContext> related; + ScopedPtr<MemberListInfoContext> detailedTypedefs; + ScopedPtr<MemberListInfoContext> detailedEnums; + ScopedPtr<MemberListInfoContext> detailedServices; + ScopedPtr<MemberListInfoContext> detailedInterfaces; + ScopedPtr<MemberListInfoContext> detailedConstructors; + ScopedPtr<MemberListInfoContext> detailedMethods; + ScopedPtr<MemberListInfoContext> detailedRelated; + ScopedPtr<MemberListInfoContext> detailedVariables; + ScopedPtr<MemberListInfoContext> detailedProperties; + ScopedPtr<MemberListInfoContext> detailedEvents; + ScopedPtr<MemberGroupListContext> memberGroups; ScopedPtr<AllMembersListContext> allMembersList; ScopedPtr<ArgumentListContext> typeConstraints; ScopedPtr<TemplateList> examples; @@ -1556,7 +1709,7 @@ TemplateVariant ClassContext::get(const char *n) const class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Private> { public: - Private(NamespaceDef *nd) : DefinitionContext(nd) , m_namespaceDef(nd) + Private(NamespaceDef *nd) : DefinitionContext<NamespaceContext::Private>(nd) , m_namespaceDef(nd) { addProperty("title",this,&Private::title); addProperty("highlight",this,&Private::highlight); @@ -1601,7 +1754,7 @@ TemplateVariant NamespaceContext::get(const char *n) const class FileContext::Private : public DefinitionContext<FileContext::Private> { public: - Private(FileDef *fd) : DefinitionContext(fd) , m_fileDef(fd) + Private(FileDef *fd) : DefinitionContext<FileContext::Private>(fd) , m_fileDef(fd) { addProperty("title",this,&Private::title); addProperty("highlight",this,&Private::highlight); @@ -1651,7 +1804,7 @@ TemplateVariant FileContext::get(const char *n) const class DirContext::Private : public DefinitionContext<DirContext::Private> { public: - Private(DirDef *dd) : DefinitionContext(dd) , m_dirDef(dd) + Private(DirDef *dd) : DefinitionContext<DirContext::Private>(dd) , m_dirDef(dd) { addProperty("title",this,&Private::title); addProperty("highlight",this,&Private::highlight); @@ -1702,7 +1855,7 @@ TemplateVariant DirContext::get(const char *n) const class PageContext::Private : public DefinitionContext<PageContext::Private> { public: - Private(PageDef *pd) : DefinitionContext(pd) , m_pageDef(pd) + Private(PageDef *pd) : DefinitionContext<PageContext::Private>(pd) , m_pageDef(pd) { addProperty("title",this,&Private::title); addProperty("highlight",this,&Private::highlight); @@ -1857,7 +2010,7 @@ TemplateVariant createLinkedText(Definition *def,const QCString &relPath,const Q class MemberContext::Private : public DefinitionContext<MemberContext::Private> { public: - Private(MemberDef *md) : DefinitionContext(md) , m_memberDef(md) + Private(MemberDef *md) : DefinitionContext<MemberContext::Private>(md) , m_memberDef(md) { addProperty("declType", this,&Private::declType); addProperty("declArgs", this,&Private::declArgs); @@ -1871,11 +2024,14 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> addProperty("isEnumeration", this,&Private::isEnumeration); addProperty("isEnumValue", this,&Private::isEnumValue); addProperty("isAnonymous", this,&Private::isAnonymous); + addProperty("isRelated", this,&Private::isRelated); addProperty("hasDetails", this,&Private::hasDetails); addProperty("exception", this,&Private::exception); addProperty("bitfields", this,&Private::bitfields); addProperty("initializer", this,&Private::initializer); - addProperty("oneLineInitializer", this,&Private::oneLineInitializer); + addProperty("initializerAsCode", this,&Private::initializerAsCode); + addProperty("hasOneLineInitializer", this,&Private::hasOneLineInitializer); + addProperty("hasMultiLineInitializer", this,&Private::hasMultiLineInitializer); addProperty("templateArgs", this,&Private::templateArgs); addProperty("templateAlias", this,&Private::templateAlias); addProperty("propertyAttrs", this,&Private::propertyAttrs); @@ -1892,6 +2048,22 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> addProperty("labels", this,&Private::labels); addProperty("enumBaseType", this,&Private::enumBaseType); addProperty("enumValues", this,&Private::enumValues); + addProperty("paramDocs", this,&Private::paramDocs); + addProperty("reimplements", this,&Private::reimplements); + addProperty("implements", this,&Private::implements); + addProperty("reimplementedBy", this,&Private::reimplementedBy); + addProperty("implementedBy", this,&Private::implementedBy); + addProperty("examples", this,&Private::examples); + addProperty("typeConstraints", this,&Private::typeConstraints); + addProperty("functionQualifier", this,&Private::functionQualifier); + addProperty("sourceRefs", this,&Private::sourceRefs); + addProperty("sourceRefBys", this,&Private::sourceRefBys); + addProperty("hasSources", this,&Private::hasSources); + addProperty("sourceCode", this,&Private::sourceCode); + addProperty("hasCallGraph", this,&Private::hasCallGraph); + addProperty("callGraph", this,&Private::callGraph); + addProperty("hasCallerGraph", this,&Private::hasCallerGraph); + addProperty("callerGraph", this,&Private::callerGraph); if (md && md->isProperty()) { @@ -1961,6 +2133,25 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> { return createLinkedText(m_memberDef,relPathAsString(),m_memberDef->initializer()); } + TemplateVariant initializerAsCode() const + { + if (!m_cache.initializerParsed) + { + QCString scopeName; + if (m_memberDef->getClassDef()) + { + scopeName = m_memberDef->getClassDef()->name(); + } + else if (m_memberDef->getNamespaceDef()) + { + scopeName = m_memberDef->getNamespaceDef()->name(); + } + m_cache.initializer = parseCode(m_memberDef,scopeName,relPathAsString(), + m_memberDef->initializer()); + m_cache.initializerParsed = TRUE; + } + return m_cache.initializer; + } TemplateVariant isDefine() const { return m_memberDef->isDefine(); @@ -1970,14 +2161,22 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> QCString name = m_memberDef->name(); return !name.isEmpty() && name.at(0)=='@'; } + TemplateVariant isRelated() const + { + return m_memberDef->isRelated(); + } TemplateVariant enumBaseType() const { return m_memberDef->enumBaseType(); } - TemplateVariant oneLineInitializer() const + TemplateVariant hasOneLineInitializer() const { return m_memberDef->hasOneLineInitializer(); } + TemplateVariant hasMultiLineInitializer() const + { + return m_memberDef->hasMultiLineInitializer(); + } TemplateVariant enumValues() const { if (!m_cache.enumValues) @@ -1987,23 +2186,27 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> { m_cache.enumValues.reset(new MemberListContext(ml)); } + else + { + m_cache.enumValues.reset(new MemberListContext); + } } - if (m_cache.enumValues) - { - return m_cache.enumValues.get(); - } - else - { - return FALSE; - } + return m_cache.enumValues.get(); } TemplateVariant templateArgs() const { - if (!m_cache.templateArgs) + if (!m_cache.templateArgs && m_memberDef->templateArguments()) { m_cache.templateArgs.reset(new ArgumentListContext(m_memberDef->templateArguments(),m_memberDef,relPathAsString())); } - return m_cache.templateArgs.get(); + if (m_cache.templateArgs) + { + return m_cache.templateArgs.get(); + } + else + { + return TemplateVariant(FALSE); + } } TemplateVariant templateAlias() const { @@ -2056,15 +2259,12 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> { m_cache.arguments.reset(new ArgumentListContext(defArgList,m_memberDef,relPathAsString())); } + else + { + m_cache.arguments.reset(new ArgumentListContext); + } } - if (m_cache.arguments) - { - return m_cache.arguments.get(); - } - else - { - return FALSE; - } + return m_cache.arguments.get(); } TemplateVariant hasParameterList() const { @@ -2109,8 +2309,6 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> if (tal->count()>0) { ArgumentListContext *al = new ArgumentListContext(tal,m_memberDef,relPathAsString()); - // since a TemplateVariant does take ownership of the object, we add it - // a separate list just to be able to delete it and avoid a memory leak m_cache.templateArgList.append(al); tl->append(al); } @@ -2118,7 +2316,7 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> } else { - if (cd && !m_memberDef->isTemplateSpecialization()) + if (cd && !m_memberDef->isRelated() && !m_memberDef->isTemplateSpecialization()) { QList<ArgumentList> tempParamLists; cd->getTemplateParameterLists(tempParamLists); @@ -2130,8 +2328,6 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> if (tal->count()>0) { ArgumentListContext *al = new ArgumentListContext(tal,m_memberDef,relPathAsString()); - // since a TemplateVariant does take ownership of the object, we add it - // a separate list just to be able to delete it and avoid a memory leak m_cache.templateArgList.append(al); tl->append(al); } @@ -2141,8 +2337,6 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> { ArgumentListContext *al = new ArgumentListContext( m_memberDef->templateArguments(),m_memberDef,relPathAsString()); - // since a TemplateVariant does take ownership of the object, we add it - // a separate list just to be able to delete it and avoid a memory leak m_cache.templateArgList.append(al); tl->append(al); } @@ -2156,14 +2350,7 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> addTemplateDecls(tl); m_cache.templateDecls.reset(tl); } - if (m_cache.templateDecls) - { - return m_cache.templateDecls.get(); - } - else - { - return TemplateVariant(FALSE); - } + return m_cache.templateDecls.get(); } TemplateVariant labels() const { @@ -2171,37 +2358,354 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private> { QStrList sl; m_memberDef->getLabels(sl,m_memberDef->getOuterScope()); + TemplateList *tl = new TemplateList; if (sl.count()>0) { - TemplateList *tl = new TemplateList; QStrListIterator it(sl); for (;it.current();++it) { tl->append(*it); } - m_cache.labels.reset(tl); + } + m_cache.labels.reset(tl); + } + return m_cache.labels.get(); + } + TemplateVariant paramDocs() const + { + if (!m_cache.paramDocs) + { + if (m_memberDef->argumentList() && m_memberDef->argumentList()->hasDocumentation()) + { + QCString paramDocs; + ArgumentListIterator ali(*m_memberDef->argumentList()); + Argument *a; + // convert the parameter documentation into a list of @param commands + for (ali.toFirst();(a=ali.current());++ali) + { + if (a->hasDocumentation()) + { + QCString direction = extractDirection(a->docs); + paramDocs+="@param"+direction+" "+a->name+" "+a->docs; + } + } + m_cache.paramDocs.reset(new TemplateVariant(parseDoc(m_memberDef, + m_memberDef->docFile(),m_memberDef->docLine(), + relPathAsString(),paramDocs,FALSE))); + } + else + { + m_cache.paramDocs.reset(new TemplateVariant("")); + } + } + return *m_cache.paramDocs; + } + TemplateVariant implements() const + { + if (!m_cache.implements) + { + MemberDef *md = m_memberDef->reimplements(); + m_cache.implements.reset(new TemplateList); + if (md) + { + ClassDef *cd = md->getClassDef(); + if (cd && (md->virtualness()==Pure || cd->compoundType()==ClassDef::Interface)) + { + MemberContext *mc = new MemberContext(md); + m_cache.implementsMember.reset(mc); + m_cache.implements->append(mc); + } + } + } + return m_cache.implements.get(); + } + TemplateVariant reimplements() const + { + if (!m_cache.reimplements) + { + MemberDef *md = m_memberDef->reimplements(); + m_cache.reimplements.reset(new TemplateList); + if (md) + { + ClassDef *cd = md->getClassDef(); + if (cd && md->virtualness()!=Pure && cd->compoundType()!=ClassDef::Interface) + { + MemberContext *mc = new MemberContext(md); + m_cache.reimplementsMember.reset(mc); + m_cache.reimplements->append(mc); + } + } + } + return m_cache.reimplements.get(); + } + TemplateVariant implementedBy() const + { + if (!m_cache.implementedBy) + { + MemberList *ml = m_memberDef->reimplementedBy(); + m_cache.implementedBy.reset(new TemplateList); + if (ml) + { + MemberListIterator mli(*ml); + MemberDef *md=0; + for (mli.toFirst();(md=mli.current());++mli) + { + ClassDef *cd = md->getClassDef(); + if (cd && (md->virtualness()==Pure || cd->compoundType()==ClassDef::Interface)) + { + MemberContext *mc = new MemberContext(md); + m_cache.implementedByMembers.append(mc); + m_cache.implementedBy->append(mc); + } + } + } + } + return m_cache.implementedBy.get(); + } + TemplateVariant reimplementedBy() const + { + if (!m_cache.reimplementedBy) + { + m_cache.reimplementedBy.reset(new TemplateList); + MemberList *ml = m_memberDef->reimplementedBy(); + if (ml) + { + MemberListIterator mli(*ml); + MemberDef *md=0; + for (mli.toFirst();(md=mli.current());++mli) + { + ClassDef *cd = md->getClassDef(); + if (cd && md->virtualness()!=Pure && cd->compoundType()!=ClassDef::Interface) + { + MemberContext *mc = new MemberContext(md); + m_cache.reimplementedByMembers.append(mc); + m_cache.reimplementedBy->append(mc); + } + } } } - if (m_cache.labels) + return m_cache.reimplementedBy.get(); + } + void addExamples(TemplateList *list) const + { + if (m_memberDef->hasExamples()) { - return m_cache.labels.get(); + ExampleSDict::Iterator it(*m_memberDef->getExamples()); + Example *ex; + for (it.toFirst();(ex=it.current());++it) + { + TemplateStruct *s = new TemplateStruct; + m_cache.exampleList.append(s); + s->set("text",ex->name); + s->set("isLinkable",TRUE); + s->set("anchor",ex->anchor); + s->set("fileName",ex->file); + list->append(s); + } + } + } + TemplateVariant examples() const + { + if (!m_cache.examples) + { + TemplateList *exampleList = new TemplateList; + addExamples(exampleList); + m_cache.examples.reset(exampleList); + } + return m_cache.examples.get(); + } + TemplateVariant typeConstraints() const + { + if (!m_cache.typeConstraints && m_memberDef->typeConstraints()) + { + m_cache.typeConstraints.reset(new ArgumentListContext(m_memberDef->typeConstraints(),m_memberDef,relPathAsString())); } else { - return TemplateVariant(FALSE); + m_cache.typeConstraints.reset(new ArgumentListContext); + } + return m_cache.typeConstraints.get(); + } + TemplateVariant functionQualifier() const + { + if (!m_memberDef->isObjCMethod() && + (m_memberDef->isFunction() || m_memberDef->isSlot() || + m_memberDef->isPrototype() || m_memberDef->isSignal() + ) + ) + { + return "()"; + } + else + { + return ""; + } + } + TemplateVariant sourceRefs() const + { + if (!m_cache.sourceRefs) + { + m_cache.sourceRefs.reset(new MemberListContext(m_memberDef->getReferencesMembers(),TRUE)); + } + return m_cache.sourceRefs.get(); + } + TemplateVariant sourceRefBys() const + { + if (!m_cache.sourceRefBys) + { + m_cache.sourceRefBys.reset(new MemberListContext(m_memberDef->getReferencedByMembers(),TRUE)); + } + return m_cache.sourceRefBys.get(); + } + TemplateVariant hasSources() const + { + return TemplateVariant(m_memberDef->hasSources()); + } + TemplateVariant sourceCode() const + { + if (!m_cache.sourceCodeParsed) + { + QCString codeFragment; + FileDef *fd = m_memberDef->getBodyDef(); + int startLine = m_memberDef->getStartBodyLine(); + int endLine = m_memberDef->getEndBodyLine(); + if (fd && readCodeFragment(fd->absFilePath(), + startLine,endLine,codeFragment) + ) + { + QCString scopeName; + if (m_memberDef->getClassDef()) + { + scopeName = m_memberDef->getClassDef()->name(); + } + else if (m_memberDef->getNamespaceDef()) + { + scopeName = m_memberDef->getNamespaceDef()->name(); + } + m_cache.sourceCode = parseCode(m_memberDef,scopeName,relPathAsString(),codeFragment,startLine,endLine,TRUE); + m_cache.sourceCodeParsed = TRUE; + } + } + return m_cache.sourceCode; + } + DotCallGraph *getCallGraph() const + { + if (!m_cache.callGraph) + { + m_cache.callGraph.reset(new DotCallGraph(m_memberDef,FALSE)); + } + return m_cache.callGraph.get(); + } + TemplateVariant hasCallGraph() const + { + static bool haveDot = Config_getBool("HAVE_DOT"); + static bool callGraph = Config_getBool("CALL_GRAPH"); + if ((callGraph || m_memberDef->hasCallGraph()) && haveDot && + (m_memberDef->isFunction() || m_memberDef->isSlot() || m_memberDef->isSignal())) + { + DotCallGraph *cg = getCallGraph(); + return !cg->isTooBig() && !cg->isTrivial(); + } + return TemplateVariant(FALSE); + } + TemplateVariant callGraph() const + { + if (hasCallGraph().toBool()) + { + DotCallGraph *cg = getCallGraph(); + QGString result; + FTextStream t(&result); + cg->writeGraph(t,BITMAP, + g_globals.outputDir, + m_memberDef->getOutputFileBase()+Doxygen::htmlFileExtension, + relPathAsString(),TRUE,g_globals.dynSectionId + ); + g_globals.dynSectionId++; + return TemplateVariant(result.data(),TRUE); + } + else + { + return TemplateVariant(""); + } + } + DotCallGraph *getCallerGraph() const + { + if (!m_cache.callerGraph) + { + m_cache.callerGraph.reset(new DotCallGraph(m_memberDef,TRUE)); + } + return m_cache.callerGraph.get(); + } + TemplateVariant hasCallerGraph() const + { + static bool haveDot = Config_getBool("HAVE_DOT"); + static bool callerGraph = Config_getBool("CALLER_GRAPH"); + if ((callerGraph || m_memberDef->hasCallerGraph()) && haveDot && + (m_memberDef->isFunction() || m_memberDef->isSlot() || m_memberDef->isSignal())) + { + DotCallGraph *cg = getCallerGraph(); + return !cg->isTooBig() && !cg->isTrivial(); + } + return TemplateVariant(FALSE); + } + TemplateVariant callerGraph() const + { + if (hasCallerGraph().toBool()) + { + DotCallGraph *cg = getCallerGraph(); + QGString result; + FTextStream t(&result); + cg->writeGraph(t,BITMAP, + g_globals.outputDir, + m_memberDef->getOutputFileBase()+Doxygen::htmlFileExtension, + relPathAsString(),TRUE,g_globals.dynSectionId + ); + g_globals.dynSectionId++; + return TemplateVariant(result.data(),TRUE); + } + else + { + return TemplateVariant(""); } } private: MemberDef *m_memberDef; struct Cachable { + Cachable() : initializerParsed(FALSE), sourceCodeParsed(FALSE) + { + implementedByMembers.setAutoDelete(TRUE); + reimplementedByMembers.setAutoDelete(TRUE); + templateArgList.setAutoDelete(TRUE); + exampleList.setAutoDelete(TRUE); + } ScopedPtr<ArgumentListContext> templateArgs; ScopedPtr<ArgumentListContext> arguments; ScopedPtr<MemberListContext> enumValues; ScopedPtr<ClassContext> classDef; ScopedPtr<TemplateList> templateDecls; + ScopedPtr<TemplateVariant> paramDocs; + ScopedPtr<TemplateList> implements; + ScopedPtr<MemberContext> implementsMember; + ScopedPtr<TemplateList> reimplements; + ScopedPtr<MemberContext> reimplementsMember; + ScopedPtr<TemplateList> implementedBy; + ScopedPtr<MemberListContext> sourceRefs; + ScopedPtr<MemberListContext> sourceRefBys; + ScopedPtr<DotCallGraph> callGraph; + ScopedPtr<DotCallGraph> callerGraph; + QList<MemberContext> implementedByMembers; + ScopedPtr<TemplateList> reimplementedBy; + QList<MemberContext> reimplementedByMembers; QList<ArgumentListContext> templateArgList; ScopedPtr<TemplateList> labels; + TemplateVariant initializer; + bool initializerParsed; + TemplateVariant sourceCode; + bool sourceCodeParsed; + ScopedPtr<TemplateList> examples; + QList<TemplateStruct> exampleList; + ScopedPtr<ArgumentListContext> typeConstraints; }; mutable Cachable m_cache; TemplateList m_propertyAttrs; @@ -2232,7 +2736,7 @@ TemplateVariant MemberContext::get(const char *n) const class ModuleContext::Private : public DefinitionContext<ModuleContext::Private> { public: - Private(GroupDef *gd) : DefinitionContext(gd) , m_groupDef(gd) + Private(GroupDef *gd) : DefinitionContext<ModuleContext::Private>(gd) , m_groupDef(gd) { addProperty("title",this,&Private::title); addProperty("highlight",this,&Private::highlight); @@ -4004,6 +4508,11 @@ class MemberListContext::Private : public GenericNodeListContext<MemberContext> } }; +MemberListContext::MemberListContext() +{ + p = new Private; +} + MemberListContext::MemberListContext(const MemberList *list) { p = new Private; @@ -4021,6 +4530,24 @@ MemberListContext::MemberListContext(const MemberList *list) } } +MemberListContext::MemberListContext(MemberSDict *list,bool doSort) +{ + p = new Private; + if (list) + { + if (doSort) + { + list->sort(); + } + MemberSDict::Iterator it(*list); + MemberDef *md; + for (it.toFirst();(md=it.current());++it) + { + p->addMember(md); + } + } +} + MemberListContext::~MemberListContext() { delete p; @@ -4158,6 +4685,11 @@ class AllMembersListContext::Private : public GenericNodeListContext<MemberInfoC } }; +AllMembersListContext::AllMembersListContext() +{ + p = new Private(0); +} + AllMembersListContext::AllMembersListContext(const MemberNameInfoSDict *ml) { p = new Private(ml); @@ -4186,19 +4718,178 @@ TemplateListIntf::ConstIterator *AllMembersListContext::createIterator() const //------------------------------------------------------------------------ +//%% struct MemberGroupInfo: member group information +//%% { +class MemberGroupInfoContext::Private : public PropertyMapper +{ + public: + Private(Definition *def,const QCString &relPath,const MemberGroup *mg) : + m_def(def), + m_relPath(relPath), + m_memberListContext(mg->members()), + m_memberGroups(def,relPath,0), m_memberGroup(mg) + { + addProperty("members", this,&Private::members); + addProperty("title", this,&Private::groupTitle); + addProperty("subtitle", this,&Private::groupSubtitle); + addProperty("anchor", this,&Private::groupAnchor); + addProperty("memberGroups", this,&Private::memberGroups); + addProperty("docs", this,&Private::docs); + } + TemplateVariant members() const + { + return &m_memberListContext; + } + TemplateVariant groupTitle() const + { + return m_memberGroup->header(); + } + TemplateVariant groupSubtitle() const + { + return ""; + } + TemplateVariant groupAnchor() const + { + return m_memberGroup->anchor(); + } + TemplateVariant memberGroups() const + { + return &m_memberGroups; + } + TemplateVariant docs() const + { + if (!m_docs) + { + QCString docs = m_memberGroup->documentation(); + if (!docs.isEmpty()) + { + m_docs.reset(new TemplateVariant( + parseDoc(m_def,"[@name docs]",-1, // TODO store file & line + m_relPath, + m_memberGroup->documentation()+"\n",FALSE))); + } + else + { + m_docs.reset(new TemplateVariant("")); + } + } + return *m_docs; + } + private: + Definition *m_def; + QCString m_relPath; + MemberListContext m_memberListContext; + MemberGroupListContext m_memberGroups; + const MemberGroup *m_memberGroup; + mutable ScopedPtr<TemplateVariant> m_docs; +}; +//%% } + +MemberGroupInfoContext::MemberGroupInfoContext(Definition *def, + const QCString &relPath,const MemberGroup *mg) +{ + p = new Private(def,relPath,mg); +} + +MemberGroupInfoContext::~MemberGroupInfoContext() +{ + delete p; +} + +TemplateVariant MemberGroupInfoContext::get(const char *name) const +{ + return p->get(name); +} + +//------------------------------------------------------------------------ + +//%% list MemberGroupList[MemberGroupInfo] : list of member groups +class MemberGroupListContext::Private : public GenericNodeListContext<MemberGroupInfoContext> +{ + public: + void addMemberGroup(Definition *def,const QCString &relPath,const MemberGroup *mg) + { + append(new MemberGroupInfoContext(def,relPath,mg)); + } +}; + +MemberGroupListContext::MemberGroupListContext() +{ + p = new Private; +} + +MemberGroupListContext::MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list) +{ + p = new Private; + if (list) + { + MemberGroupListIterator mgli(*list); + MemberGroup *mg; + for (;(mg=mgli.current());++mgli) + { + p->addMemberGroup(def,relPath,mg); + } + } +} + +MemberGroupListContext::MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *dict,bool subGrouping) +{ + p = new Private; + if (dict) + { + MemberGroupSDict::Iterator di(*dict); + const MemberGroup *mg; + for (di.toFirst();(mg=di.current());++di) + { + if (!mg->allMembersInSameSection() || !subGrouping) + { + p->addMemberGroup(def,relPath,mg); + } + } + } +} + +MemberGroupListContext::~MemberGroupListContext() +{ + delete p; +} + +// TemplateListIntf +int MemberGroupListContext::count() const +{ + return p->count(); +} + +TemplateVariant MemberGroupListContext::at(int index) const +{ + return p->at(index); +} + +TemplateListIntf::ConstIterator *MemberGroupListContext::createIterator() const +{ + return p->createIterator(); +} + + +//------------------------------------------------------------------------ + //%% struct MemberListInfo: member list information //%% { class MemberListInfoContext::Private : public PropertyMapper { public: - Private(const MemberList *ml,const QCString &title,const QCString &subtitle) : - m_memberListContext(ml), m_memberList(ml), m_title(title), m_subtitle(subtitle) - { - addProperty("members", this,&Private::members); - addProperty("title", this,&Private::title); - addProperty("subtitle",this,&Private::subtitle); - addProperty("anchor", this,&Private::anchor); - // TODO: member groups + Private(Definition *def,const QCString &relPath,const MemberList *ml,const QCString &title,const QCString &subtitle) : + m_memberListContext(ml), + m_memberGroups(def,relPath,ml ? ml->getMemberGroupList() : 0), + m_memberList(ml), + m_title(title), + m_subtitle(subtitle) + { + addProperty("members", this,&Private::members); + addProperty("title", this,&Private::title); + addProperty("subtitle", this,&Private::subtitle); + addProperty("anchor", this,&Private::anchor); + addProperty("memberGroups", this,&Private::memberGroups); } TemplateVariant members() const { @@ -4216,18 +4907,24 @@ class MemberListInfoContext::Private : public PropertyMapper { return m_memberList->listTypeAsString(m_memberList->listType()); } + TemplateVariant memberGroups() const + { + return &m_memberGroups; + } private: MemberListContext m_memberListContext; + MemberGroupListContext m_memberGroups; const MemberList *m_memberList; QCString m_title; QCString m_subtitle; }; //%% } -MemberListInfoContext::MemberListInfoContext(const MemberList *ml, +MemberListInfoContext::MemberListInfoContext( + Definition *def,const QCString &relPath,const MemberList *ml, const QCString &title,const QCString &subtitle) { - p = new Private(ml,title,subtitle); + p = new Private(def,relPath,ml,title,subtitle); } MemberListInfoContext::~MemberListInfoContext() @@ -4345,6 +5042,11 @@ class ArgumentListContext::Private : public GenericNodeListContext<ArgumentConte } }; +ArgumentListContext::ArgumentListContext() +{ + p = new Private; +} + ArgumentListContext::ArgumentListContext(const ArgumentList *list, Definition *def,const QCString &relPath) { diff --git a/src/context.h b/src/context.h index 75f1579..6ae2c28 100644 --- a/src/context.h +++ b/src/context.h @@ -25,11 +25,15 @@ class GroupDef; class GroupList; struct IncludeInfo; class MemberList; +class MemberSDict; class MemberDef; struct Argument; class ArgumentList; class MemberNameInfoSDict; struct MemberInfo; +class MemberGroup; +class MemberGroupSDict; +class MemberGroupList; //---------------------------------------------------- @@ -649,7 +653,9 @@ class InheritanceListContext : public TemplateListIntf class MemberListContext : public TemplateListIntf { public: + MemberListContext(); MemberListContext(const MemberList *ml); + MemberListContext(MemberSDict *ml,bool doSort); ~MemberListContext(); // TemplateListIntf @@ -664,10 +670,48 @@ class MemberListContext : public TemplateListIntf //---------------------------------------------------- +class MemberGroupInfoContext : public TemplateStructIntf +{ + public: + MemberGroupInfoContext(Definition *def,const QCString &relPath,const MemberGroup *mg); + ~MemberGroupInfoContext(); + + // TemplateStructIntf methods + virtual TemplateVariant get(const char *name) const; + + private: + class Private; + Private *p; +}; + +//---------------------------------------------------- + +class MemberGroupListContext : public TemplateListIntf +{ + public: + MemberGroupListContext(); + MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list); + MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *mgDict,bool subGrouping); + ~MemberGroupListContext(); + + // TemplateListIntf + virtual int count() const; + virtual TemplateVariant at(int index) const; + virtual TemplateListIntf::ConstIterator *createIterator() const; + + private: + class Private; + Private *p; +}; + + +//---------------------------------------------------- + class MemberListInfoContext : public TemplateStructIntf { public: - MemberListInfoContext(const MemberList *ml,const QCString &title, + MemberListInfoContext(Definition *def,const QCString &relPath, + const MemberList *ml,const QCString &title, const QCString &subtitle=QCString()); ~MemberListInfoContext(); @@ -700,6 +744,7 @@ class MemberInfoContext : public TemplateStructIntf class AllMembersListContext : public TemplateListIntf { public: + AllMembersListContext(); AllMembersListContext(const MemberNameInfoSDict *ml); ~AllMembersListContext(); @@ -734,6 +779,7 @@ class ArgumentContext : public TemplateStructIntf class ArgumentListContext : public TemplateListIntf { public: + ArgumentListContext(); ArgumentListContext(const ArgumentList *al,Definition *def,const QCString &relPath); ~ArgumentListContext(); diff --git a/src/definition.cpp b/src/definition.cpp index 2c05f29..46147fc 100644 --- a/src/definition.cpp +++ b/src/definition.cpp @@ -1050,6 +1050,13 @@ void Definition::setBodyDef(FileDef *fd) m_impl->body->fileDef=fd; } +bool Definition::hasSources() const +{ + return m_impl->body && m_impl->body->startLine!=-1 && + m_impl->body->endLine>=m_impl->body->startLine && + m_impl->body->fileDef; +} + /*! Write code of this definition into the documentation */ void Definition::writeInlineCode(OutputList &ol,const char *scopeName) { @@ -1057,9 +1064,7 @@ void Definition::writeInlineCode(OutputList &ol,const char *scopeName) ol.pushGeneratorState(); //printf("Source Fragment %s: %d-%d bodyDef=%p\n",name().data(), // m_startBodyLine,m_endBodyLine,m_bodyDef); - if (inlineSources && - m_impl->body && m_impl->body->startLine!=-1 && - m_impl->body->endLine>=m_impl->body->startLine && m_impl->body->fileDef) + if (inlineSources && hasSources()) { QCString codeFragment; int actualStart=m_impl->body->startLine,actualEnd=m_impl->body->endLine; diff --git a/src/definition.h b/src/definition.h index 9de08fd..f444cc5 100644 --- a/src/definition.h +++ b/src/definition.h @@ -137,18 +137,18 @@ class Definition : public DefinitionIntf virtual QCString getSourceAnchor() const; /*! Returns the detailed description of this definition */ - QCString documentation() const; - + virtual QCString documentation() const; + /*! Returns the line number at which the detailed documentation was found. */ int docLine() const; - /*! Returns the file in which the detailed documentation block was found. + /*! Returns the file in which the detailed documentation block was found. * This can differ from getDefFileName(). */ QCString docFile() const; /*! Returns the brief description of this definition. This can include commands. */ - QCString briefDescription(bool abbreviate=FALSE) const; + virtual QCString briefDescription(bool abbreviate=FALSE) const; /*! Returns a plain text version of the brief description suitable for use * as a tool tip. @@ -259,6 +259,7 @@ class Definition : public DefinitionIntf MemberSDict *getReferencedByMembers() const; bool hasSections() const; + bool hasSources() const; /** returns TRUE if this class has a brief description */ bool hasBriefDescription() const; diff --git a/src/htmlgen.h b/src/htmlgen.h index 6fb168b..366027d 100644 --- a/src/htmlgen.h +++ b/src/htmlgen.h @@ -282,7 +282,7 @@ class HtmlGenerator : public OutputGenerator //{ t << "<tr><td valign=\"top\"><em>"; } { t << "<tr><td class=\"fieldname\"><em>"; } void endDescTableTitle() - { t << "</em> </td>"; } + { t << "</em> </td>"; } void startDescTableData() //{ t << "<td>" << endl; } { t << "<td class=\"fielddoc\">" << endl; } diff --git a/src/markdown.cpp b/src/markdown.cpp index eb5a2a2..ac824f4 100644 --- a/src/markdown.cpp +++ b/src/markdown.cpp @@ -1974,6 +1974,9 @@ static QCString processBlocks(const QCString &s,int indent) end++; } +#if 0 // commented out, since starting with a comment block is probably a usage error + // see also http://stackoverflow.com/q/20478611/784672 + // special case when the documentation starts with a code block // since the first line is skipped when looking for a code block later on. if (end>codeBlockIndent && isCodeBlock(data,0,end,blockIndent)) @@ -1982,6 +1985,7 @@ static QCString processBlocks(const QCString &s,int indent) end=i+1; pi=-1; } +#endif // process each line while (i<size) @@ -2288,9 +2292,13 @@ void MarkdownFileParser::parseInput(const char *fileName, QCString titleFn = QFileInfo(fileName).baseName().utf8(); QCString fn = QFileInfo(fileName).fileName().utf8(); static QCString mdfileAsMainPage = Config_getString("USE_MDFILE_AS_MAINPAGE"); - if (id.isEmpty()) id = markdownFileNameToId(fileName); + if (id.isEmpty()) id = markdownFileNameToId(fileName); if (title.isEmpty()) title = titleFn; - if (fn==mdfileAsMainPage) + if (!mdfileAsMainPage.isEmpty() && + (fn==mdfileAsMainPage || // name reference + QFileInfo(fileName).absFilePath()== + QFileInfo(mdfileAsMainPage).absFilePath()) // file reference with path + ) { docs.prepend("@mainpage\n"); } diff --git a/src/memberdef.cpp b/src/memberdef.cpp index 2059341..5d88d4a 100644 --- a/src/memberdef.cpp +++ b/src/memberdef.cpp @@ -449,27 +449,6 @@ static void writeTemplatePrefix(OutputList &ol,ArgumentList *al) ol.docify("> "); } -QCString extractDirection(QCString &docs) -{ - QRegExp re("\\[[^\\]]+\\]"); // [...] - int l=0; - if (re.match(docs,0,&l)==0) - { - int inPos = docs.find("in", 1,FALSE); - int outPos = docs.find("out",1,FALSE); - bool input = inPos!=-1 && inPos<l; - bool output = outPos!=-1 && outPos<l; - if (input || output) // in,out attributes - { - docs = docs.mid(l); // strip attributes - if (input && output) return "[in,out]"; - else if (input) return "[in]"; - else if (output) return "[out]"; - } - } - return QCString(); -} - //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- @@ -4985,3 +4964,33 @@ void combineDeclarationAndDefinition(MemberDef *mdec,MemberDef *mdef) } } +QCString MemberDef::briefDescription(bool abbr) const +{ + if (m_impl->templateMaster) + { + return m_impl->templateMaster->briefDescription(abbr); + } + else + { + return Definition::briefDescription(abbr); + } +} + +QCString MemberDef::documentation() const +{ + if (m_impl->templateMaster) + { + return m_impl->templateMaster->documentation(); + } + else + { + return Definition::documentation(); + } +} + +const ArgumentList *MemberDef::typeConstraints() const +{ + return m_impl->typeConstraints; +} + + diff --git a/src/memberdef.h b/src/memberdef.h index aa17798..926906c 100644 --- a/src/memberdef.h +++ b/src/memberdef.h @@ -245,6 +245,14 @@ class MemberDef : public Definition QCString getDeclType() const; void getLabels(QStrList &sl,Definition *container) const; + const ArgumentList *typeConstraints() const; + + // overrules + QCString documentation() const; + QCString briefDescription(bool abbr=FALSE) const; + + + //----------------------------------------------------------------------------------- // ---- setters ----- //----------------------------------------------------------------------------------- diff --git a/src/membergroup.h b/src/membergroup.h index 64a521b..c5a2d0c 100644 --- a/src/membergroup.h +++ b/src/membergroup.h @@ -61,8 +61,8 @@ class MemberGroup MemberListType lt, ClassDef *inheritedFrom,const QCString &inheritId); - QCString documentation() { return doc; } - bool allMembersInSameSection() { return inSameSection; } + QCString documentation() const { return doc; } + bool allMembersInSameSection() const { return inSameSection; } void addToDeclarationSection(); int countDecMembers(GroupDef *gd=0); int countDocMembers(); diff --git a/src/portable.cpp b/src/portable.cpp index 7b78439..258c50f 100644 --- a/src/portable.cpp +++ b/src/portable.cpp @@ -84,7 +84,11 @@ int portable_system(const char *command,const char *args,bool commandHasConsole) #else // Other Unices just use fork pid = fork(); - if (pid==-1) return -1; + if (pid==-1) + { + perror("fork error"); + return -1; + } if (pid==0) { const char * argv[4]; diff --git a/src/template.cpp b/src/template.cpp index e3eecf9..75596f2 100644 --- a/src/template.cpp +++ b/src/template.cpp @@ -104,8 +104,7 @@ class TemplateVariant::Private bool boolVal; const TemplateStructIntf *strukt; const TemplateListIntf *list; - FuncType func; - const void *obj; + Delegate delegate; bool raw; }; @@ -158,12 +157,11 @@ TemplateVariant::TemplateVariant(const TemplateListIntf *l) p->list = l; } -TemplateVariant::TemplateVariant(const void *obj,FuncType f) +TemplateVariant::TemplateVariant(const TemplateVariant::Delegate &delegate) { p = new Private; p->type = Function; - p->func = f; - p->obj = obj; + p->delegate = delegate; } TemplateVariant::~TemplateVariant() @@ -184,8 +182,7 @@ TemplateVariant::TemplateVariant(const TemplateVariant &v) case String: p->strVal = v.p->strVal; break; case Struct: p->strukt = v.p->strukt; break; case List: p->list = v.p->list; break; - case Function: p->func = v.p->func; - p->obj = v.p->obj; break; + case Function: p->delegate= v.p->delegate;break; } } @@ -201,8 +198,7 @@ TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v) case String: p->strVal = v.p->strVal; break; case Struct: p->strukt = v.p->strukt; break; case List: p->list = v.p->list; break; - case Function: p->func = v.p->func; - p->obj = v.p->obj; break; + case Function: p->delegate= v.p->delegate;break; } return *this; } @@ -305,7 +301,7 @@ const TemplateListIntf *TemplateVariant::toList() const TemplateVariant TemplateVariant::call(const QValueList<TemplateVariant> &args) { - if (p->type==Function) return p->func(p->obj,args); + if (p->type==Function) return p->delegate(args); return TemplateVariant(); } @@ -766,14 +762,12 @@ class FilterDivisibleBy public: static TemplateVariant apply(const TemplateVariant &v,const TemplateVariant &n) { - printf("FilterDivisibleBy::apply()\n"); if (!v.isValid() || !n.isValid()) { return TemplateVariant(); } if (v.type()==TemplateVariant::Integer && n.type()==TemplateVariant::Integer) { - printf("FilterDivisibleBy(%d,%d)=%d",v.toInt(),n.toInt(),(v.toInt()%n.toInt())==0); return TemplateVariant((v.toInt()%n.toInt())==0); } else @@ -2045,10 +2039,13 @@ class TemplateNodeMsg : public TemplateNodeCreator<TemplateNodeMsg> TemplateContextImpl* ci = dynamic_cast<TemplateContextImpl*>(c); TemplateEscapeIntf *escIntf = ci->escapeIntf(); ci->setEscapeIntf(0); // avoid escaping things we send to standard out + bool enable = ci->spacelessEnabled(); + ci->enableSpaceless(FALSE); FTextStream ts(stdout); m_nodes.render(ts,c); ts << endl; ci->setEscapeIntf(escIntf); + ci->enableSpaceless(enable); } private: TemplateNodeList m_nodes; @@ -2423,7 +2420,8 @@ class TemplateNodeTree : public TemplateNodeCreator<TemplateNodeTree> if (list && list->count()>0) // non-empty list { TreeContext childCtx(this,list,ctx->templateCtx); - TemplateVariant children(&childCtx,renderChildrenStub); +// TemplateVariant children(&childCtx,renderChildrenStub); + TemplateVariant children(TemplateVariant::Delegate::fromFunction(&childCtx,renderChildrenStub)); children.setRaw(TRUE); c->set("children",children); m_treeNodes.render(ss,c); diff --git a/src/template.h b/src/template.h index f5598f1..22dca13 100644 --- a/src/template.h +++ b/src/template.h @@ -26,7 +26,7 @@ class TemplateEngine; * When the template engine encounters a variable, it evaluates that variable and * replaces it with the result. Variable names consist of any combination of * alphanumeric characters and the underscore ("_"). - * Use a dot (.) to access attributes of a variable. + * Use a dot (.) to access attributes of a structured variable. * * One can modify variables for display by using \b filters, for example: * `{{ value|default:"nothing" }}` @@ -40,28 +40,33 @@ class TemplateEngine; * * Supported Django tags: * - `for ... empty ... endfor` - * - `if ... else ... endif` - * - `block ... endblock` + * - `if ... else ... endif` + * - `block ... endblock` * - `extend` * - `include` * - `with ... endwith` * - `spaceless ... endspaceless` + * - `cycle` + * + * Extension tags: + * - `create` which instantiates a template and writes the result to a file. + * The syntax is `{% create 'filename' from 'template' %}`. + * - `recursetree` + * - `markers` + * - `msg` ... `endmsg` + * - `set` * * Supported Django filters: * - `default` * - `length` * - `add` - * - * Extension tags: - * - `create` which instantiates a template and writes the result to a file. - * The syntax is `{% create 'filename' from 'template' %}`. - * - `recursetree` - * - `markers` + * - `divisibleby` * * Extension filters: * - `stripPath` * - `nowrap` * - `prepend` + * - `append` * * @{ */ @@ -70,8 +75,50 @@ class TemplateEngine; class TemplateVariant { public: - /** Signature of the callback function, used for function type variants */ - typedef TemplateVariant (*FuncType)(const void *obj, const QValueList<TemplateVariant> &args); + /** @brief Helper class to create a delegate that can store a function/method call. */ + class Delegate + { + public: + /** Callback type to use when creating a delegate from a function. */ + typedef TemplateVariant (*StubType)(const void *obj, const QValueList<TemplateVariant> &args); + + Delegate() : m_objectPtr(0) , m_stubPtr(0) {} + + /** Creates a delegate given an object. The method to call is passed as a template parameter */ + template <class T, TemplateVariant (T::*TMethod)(const QValueList<TemplateVariant> &) const> + static Delegate fromMethod(const T* objectPtr) + { + Delegate d; + d.m_objectPtr = objectPtr; + d.m_stubPtr = &methodStub<T, TMethod>; + return d; + } + /** Creates a delegate given an object, and a plain function. */ + static Delegate fromFunction(const void *obj,StubType func) + { + Delegate d; + d.m_objectPtr = obj; + d.m_stubPtr = func; + return d; + } + + /** Invokes the function/method stored in the delegate */ + TemplateVariant operator()(const QValueList<TemplateVariant> &args) const + { + return (*m_stubPtr)(m_objectPtr, args); + } + + private: + const void* m_objectPtr; + StubType m_stubPtr; + + template <class T, TemplateVariant (T::*TMethod)(const QValueList<TemplateVariant> &) const> + static TemplateVariant methodStub(const void* objectPtr, const QValueList<TemplateVariant> &args) + { + T* p = (T*)(objectPtr); + return (p->*TMethod)(args); + } + }; /** Types of data that can be stored in a TemplateVariant */ enum Type { None, Bool, Integer, String, Struct, List, Function }; @@ -109,13 +156,14 @@ class TemplateVariant */ TemplateVariant(const TemplateListIntf *l); - /** Constructs a new variant which represents a function - * @param[in] obj Opaque user defined pointer, which - * is passed back when call() is invoked. - * @param[in] func Callback function to invoke when + /** Constructs a new variant which represents a method call + * @param[in] delegate Delegate object to invoke when * calling call() on this variant. + * @note Use TemplateVariant::Delegate::fromMethod() and + * TemplateVariant::Delegate::fromFunction() to create + * Delegate objects. */ - TemplateVariant(const void *obj,FuncType func); + TemplateVariant(const Delegate &delegate); /** Destroys the Variant object */ ~TemplateVariant(); @@ -167,7 +215,7 @@ class TemplateVariant * @see setRaw() */ bool raw() const; - + private: class Private; Private *p; diff --git a/src/util.cpp b/src/util.cpp index 202ba82..42bf819 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -8057,3 +8057,26 @@ bool classVisibleInIndex(ClassDef *cd) return (allExternals && cd->isLinkable()) || cd->isLinkableInProject(); } +//---------------------------------------------------------------------------- + +QCString extractDirection(QCString &docs) +{ + QRegExp re("\\[[^\\]]+\\]"); // [...] + int l=0; + if (re.match(docs,0,&l)==0) + { + int inPos = docs.find("in", 1,FALSE); + int outPos = docs.find("out",1,FALSE); + bool input = inPos!=-1 && inPos<l; + bool output = outPos!=-1 && outPos<l; + if (input || output) // in,out attributes + { + docs = docs.mid(l); // strip attributes + if (input && output) return "[in,out]"; + else if (input) return "[in]"; + else if (output) return "[out]"; + } + } + return QCString(); +} + @@ -446,7 +446,7 @@ uint getUtf8Code( const QCString& s, int idx ); uint getUtf8CodeToLower( const QCString& s, int idx ); uint getUtf8CodeToUpper( const QCString& s, int idx ); - +QCString extractDirection(QCString &docs); #endif |