summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/context.cpp649
-rw-r--r--src/context.h2
-rw-r--r--src/definition.cpp11
-rw-r--r--src/definition.h9
-rw-r--r--src/htmlgen.h2
-rw-r--r--src/memberdef.cpp51
-rw-r--r--src/memberdef.h8
-rw-r--r--src/template.cpp24
-rw-r--r--src/template.h82
-rw-r--r--src/util.cpp23
-rw-r--r--src/util.h2
11 files changed, 752 insertions, 111 deletions
diff --git a/src/context.cpp b/src/context.cpp
index 1881147..c73c715 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;
@@ -1002,11 +1125,10 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private>
addProperty("events", this,&Private::events);
addProperty("friends", this,&Private::friends);
addProperty("relatedDecls", this,&Private::relatedDecls);
-
addProperty("typedefs", this,&Private::typedefs);
+ addProperty("enums", this,&Private::enums);
addProperty("methods", this,&Private::methods);
addProperty("relatedDefs", this,&Private::relatedDefs);
-
addProperty("nestedClasses", this,&Private::nestedClasses);
addProperty("compoundType", this,&Private::compoundType);
addProperty("templateDecls", this,&Private::templateDecls);
@@ -1316,6 +1438,10 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private>
{
return getMemberList(m_cache.typedefs,MemberListType_typedefMembers,theTranslator->trMemberTypedefDocumentation());
}
+ TemplateVariant enums() const
+ {
+ return getMemberList(m_cache.enums,MemberListType_enumMembers,theTranslator->trMemberEnumerationDocumentation());
+ }
TemplateVariant methods() const
{
return getMemberList(m_cache.methods,MemberListType_functionMembers,theTranslator->trMemberFunctionDocumentation());
@@ -1519,6 +1645,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private>
ScopedPtr<MemberListInfoContext> friends;
ScopedPtr<MemberListInfoContext> relatedDecls;
ScopedPtr<MemberListInfoContext> typedefs;
+ ScopedPtr<MemberListInfoContext> enums;
ScopedPtr<MemberListInfoContext> methods;
ScopedPtr<MemberListInfoContext> relatedDefs;
ScopedPtr<AllMembersListContext> allMembersList;
@@ -1871,11 +1998,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 +2022,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 +2107,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 +2135,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)
@@ -2109,8 +2282,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 +2289,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 +2301,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 +2310,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);
}
@@ -2191,17 +2358,379 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private>
return TemplateVariant(FALSE);
}
}
+ 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();
+ if (md)
+ {
+ ClassDef *cd = md->getClassDef();
+ if (cd && (md->virtualness()==Pure || cd->compoundType()==ClassDef::Interface))
+ {
+ m_cache.implements.reset(new TemplateList);
+ MemberContext *mc = new MemberContext(md);
+ m_cache.implementsMember.reset(mc);
+ m_cache.implements->append(mc);
+ }
+ }
+ }
+ if (m_cache.implements)
+ {
+ return m_cache.implements.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ TemplateVariant reimplements() const
+ {
+ if (!m_cache.reimplements)
+ {
+ MemberDef *md = m_memberDef->reimplements();
+ if (md)
+ {
+ ClassDef *cd = md->getClassDef();
+ if (cd && md->virtualness()!=Pure && cd->compoundType()!=ClassDef::Interface)
+ {
+ m_cache.reimplements.reset(new TemplateList);
+ MemberContext *mc = new MemberContext(md);
+ m_cache.reimplementsMember.reset(mc);
+ m_cache.reimplements->append(mc);
+ }
+ }
+ }
+ if (m_cache.reimplements)
+ {
+ return m_cache.reimplements.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ TemplateVariant implementedBy() const
+ {
+ if (!m_cache.implementedBy)
+ {
+ MemberList *ml = m_memberDef->reimplementedBy();
+ if (ml)
+ {
+ MemberListIterator mli(*ml);
+ MemberDef *md=0;
+ m_cache.implementedBy.reset(new TemplateList);
+ 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);
+ }
+ }
+ }
+ }
+ if (m_cache.implementedBy)
+ {
+ return m_cache.implementedBy.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ TemplateVariant reimplementedBy() const
+ {
+ if (!m_cache.reimplementedBy)
+ {
+ MemberList *ml = m_memberDef->reimplementedBy();
+ if (ml)
+ {
+ MemberListIterator mli(*ml);
+ MemberDef *md=0;
+ m_cache.reimplementedBy.reset(new TemplateList);
+ 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.reimplementedBy)
+ {
+ return m_cache.reimplementedBy.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ void addExamples(TemplateList *list) const
+ {
+ if (m_memberDef->hasExamples())
+ {
+ 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);
+ }
+ if (m_cache.examples)
+ {
+ return m_cache.examples.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ TemplateVariant typeConstraints() const
+ {
+ if (!m_cache.typeConstraints && m_memberDef->typeConstraints())
+ {
+ m_cache.typeConstraints.reset(new ArgumentListContext(m_memberDef->typeConstraints(),m_memberDef,relPathAsString()));
+ }
+ if (m_cache.typeConstraints)
+ {
+ return m_cache.typeConstraints.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ 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;
@@ -4021,6 +4550,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;
diff --git a/src/context.h b/src/context.h
index 75f1579..9f88b69 100644
--- a/src/context.h
+++ b/src/context.h
@@ -25,6 +25,7 @@ class GroupDef;
class GroupList;
struct IncludeInfo;
class MemberList;
+class MemberSDict;
class MemberDef;
struct Argument;
class ArgumentList;
@@ -650,6 +651,7 @@ class MemberListContext : public TemplateListIntf
{
public:
MemberListContext(const MemberList *ml);
+ MemberListContext(MemberSDict *ml,bool doSort);
~MemberListContext();
// TemplateListIntf
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>&nbsp;</td>"; }
+ { t << "</em>&#160;</td>"; }
void startDescTableData()
//{ t << "<td>" << endl; }
{ t << "<td class=\"fielddoc\">" << endl; }
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/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();
+}
+
diff --git a/src/util.h b/src/util.h
index 28d4a0c..23795f4 100644
--- a/src/util.h
+++ b/src/util.h
@@ -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