From 744d1ca52e25dfa9e3d656056d87ed7cb6320585 Mon Sep 17 00:00:00 2001 From: Dimitri van Heesch Date: Sun, 29 Dec 2013 09:47:51 +0100 Subject: More work on the template and context mechanisms --- src/classdef.cpp | 22 +- src/classdef.h | 8 +- src/context.cpp | 928 +++++++++++++++++++++++++++++++++++++++++++++------ src/context.h | 42 ++- src/filedef.cpp | 20 +- src/filedef.h | 4 + src/memberdef.cpp | 27 +- src/memberdef.h | 3 +- src/message.cpp | 9 +- src/message.h | 2 + src/namespacedef.cpp | 56 ++-- src/namespacedef.h | 1 + src/template.cpp | 388 ++++++++++++++------- src/template.h | 80 +++-- 14 files changed, 1284 insertions(+), 306 deletions(-) diff --git a/src/classdef.cpp b/src/classdef.cpp index 6404431..7e8b331 100644 --- a/src/classdef.cpp +++ b/src/classdef.cpp @@ -1767,20 +1767,24 @@ void ClassDef::writeMoreLink(OutputList &ol,const QCString &anchor) } } +bool ClassDef::visibleInParentsDeclList() const +{ + static bool extractPrivate = Config_getBool("EXTRACT_PRIVATE"); + static bool hideUndocClasses = Config_getBool("HIDE_UNDOC_CLASSES"); + static bool extractLocalClasses = Config_getBool("EXTRACT_LOCAL_CLASSES"); + bool linkable = isLinkable(); + return (name().find('@')==-1 && !isExtension() && + (protection()!=::Private || extractPrivate) && + (linkable || (!hideUndocClasses && (!isLocal() || extractLocalClasses))) + ); +} void ClassDef::writeDeclarationLink(OutputList &ol,bool &found,const char *header,bool localNames) { //static bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN"); //static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL"); - static bool hideUndocClasses = Config_getBool("HIDE_UNDOC_CLASSES"); - static bool extractLocalClasses = Config_getBool("EXTRACT_LOCAL_CLASSES"); - bool isLink = isLinkable(); SrcLangExt lang = getLanguage(); - if (isLink || - (!hideUndocClasses && - (!isLocal() || extractLocalClasses) - ) - ) + if (visibleInParentsDeclList()) { if (!found) // first class { @@ -1820,7 +1824,7 @@ void ClassDef::writeDeclarationLink(OutputList &ol,bool &found,const char *heade ol.writeString(" "); ol.insertMemberAlign(); } - if (isLink) + if (isLinkable()) { ol.writeObjectLink(getReference(), getOutputFileBase(), diff --git a/src/classdef.h b/src/classdef.h index 4e76117..6ce1e73 100644 --- a/src/classdef.h +++ b/src/classdef.h @@ -168,6 +168,9 @@ class ClassDef : public Definition /** the class is visible in a class diagram, or class hierarchy */ bool isVisibleInHierarchy(); + /** show this class in the declaration section of its parent? */ + bool visibleInParentsDeclList() const; + /** Returns the template arguments of this class * Will return 0 if not applicable. */ @@ -310,14 +313,13 @@ class ClassDef : public Definition QCString generatedFromFiles() const; const FileList &usedFiles() const; - QCString includeStatement() const; - const ArgumentList *typeConstraints() const; const ExampleSDict *exampleList() const; bool hasExamples() const; QCString getMemberListFileName() const; bool subGrouping() const; + //----------------------------------------------------------------------------------- // --- setters ---- //----------------------------------------------------------------------------------- @@ -432,6 +434,8 @@ class ClassDef : public Definition QPtrDict *visitedClasses); void getTitleForMemberListType(MemberListType type, QCString &title,QCString &subtitle); + QCString includeStatement() const; + ClassDefImpl *m_impl; diff --git a/src/context.cpp b/src/context.cpp index e573dde..02a5212 100644 --- a/src/context.cpp +++ b/src/context.cpp @@ -27,6 +27,8 @@ // TODO: pass the current file to Dot*::writeGraph, so the user can put dot graphs in other // files as well +#define ADD_PROPERTY(name) addProperty(#name,this,&Private::name); + struct ContextGlobals { enum OutputFormat @@ -453,6 +455,18 @@ class TranslateContext::Private : public PropertyMapper } return TemplateVariant(); } + TemplateVariant handleIncludeDependencyGraph(const QValueList &args) const + { + if (args.count()==1) + { + return theTranslator->trInclDepGraph(args[0].toString()); + } + else + { + err("tr.includeDependencyGraph should take one string argument, got %d\n",args.count()); + } + return TemplateVariant(); + } @@ -483,6 +497,8 @@ class TranslateContext::Private : public PropertyMapper TemplateVariant classes() const { return theTranslator->trClasses(); + // TODO: VHDL: trVhdlType(VhdlDocGen::ENTITY,FALSE) + // TODO: Fortran: trDataTypes() } TemplateVariant classList() const { @@ -669,6 +685,34 @@ class TranslateContext::Private : public PropertyMapper { return theTranslator->trAdditionalInheritedMembers(); } + TemplateVariant includeDependencyGraph() const + { + return TemplateVariant::Delegate::fromMethod(this); + } + TemplateVariant includedByDependencyGraph() const + { + return theTranslator->trInclByDepGraph(); + } + TemplateVariant gotoSourceCode() const + { + return theTranslator->trGotoSourceCode(); + } + TemplateVariant gotoDocumentation() const + { + return theTranslator->trGotoDocumentation(); + } + TemplateVariant constantgroups() const + { + return theTranslator->trConstantGroups(); + } + TemplateVariant classDocumentation() const + { + return theTranslator->trClassDocumentation(); + } + TemplateVariant compoundMembers() const + { + return theTranslator->trCompoundMembers(); + } Private() { //%% string generatedBy @@ -761,6 +805,20 @@ class TranslateContext::Private : public PropertyMapper addProperty("inheritedFrom", this,&Private::inheritedFrom); //%% string addtionalInheritedMembers addProperty("additionalInheritedMembers",this,&Private::additionalInheritedMembers); + //%% string includeDependencyGraph:container_name + addProperty("includeDependencyGraph",this,&Private::includeDependencyGraph); + //%% string includedByDependencyGraph + addProperty("includedByDependencyGraph",this,&Private::includedByDependencyGraph); + //%% string gotoSourceCode + addProperty("gotoSourceCode", this,&Private::gotoSourceCode); + //%% string gotoDocumentation + addProperty("gotoDocumentation", this,&Private::gotoDocumentation); + //%% string constantgroups + addProperty("constantgroups", this,&Private::constantgroups); + //%% string classDocumentation + addProperty("classDocumentation", this,&Private::classDocumentation); + //%% string compoundMembers + addProperty("compoundMembers", this,&Private::compoundMembers); m_javaOpt = Config_getBool("OPTIMIZE_OUTPUT_JAVA"); m_fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN"); @@ -823,6 +881,31 @@ static TemplateVariant parseCode(MemberDef *md,const QCString &scopeName,const Q return TemplateVariant(s.data(),TRUE); } +static TemplateVariant parseCode(FileDef *fd,const QCString &relPath) +{ + static bool filterSourceFiles = Config_getBool("FILTER_SOURCE_FILES"); + ParserInterface *pIntf = Doxygen::parserManager->getParser(fd->getDefFileExtension()); + pIntf->resetCodeParserState(); + QGString s; + FTextStream t(&s); + HtmlCodeGenerator codeGen(t,relPath); + pIntf->parseCode(codeGen,0, + fileToString(fd->absFilePath(),filterSourceFiles,TRUE), // the sources + fd->getLanguage(), // lang + FALSE, // isExampleBlock + 0, // exampleName + fd, // fileDef + -1, // startLine + -1, // endLine + FALSE, // inlineFragment + 0, // memberDef + TRUE, // showLineNumbers + 0, // searchCtx + TRUE // collectXRefs, TODO: should become FALSE + ); + return TemplateVariant(s.data(),TRUE); +} + //------------------------------------------------------------------------ //%% struct Symbol: shared info for all symbols @@ -1027,7 +1110,10 @@ class DefinitionContext : public PropertyMapper if (!m_cache.navPath) { TemplateList *list = new TemplateList; - fillPath(m_def,list); + if (m_def->getOuterScope() && m_def->getOuterScope()!=Doxygen::globalScope) + { + fillPath(m_def->getOuterScope(),list); + } m_cache.navPath.reset(list); } return m_cache.navPath.get(); @@ -1058,7 +1144,7 @@ class DefinitionContext : public PropertyMapper class IncludeInfoContext::Private : public PropertyMapper { public: - Private(IncludeInfo *info,SrcLangExt lang) : + Private(const IncludeInfo *info,SrcLangExt lang) : m_info(info), m_fileContext(info && info->fileDef ? info->fileDef : 0), m_lang(lang) @@ -1096,12 +1182,12 @@ class IncludeInfoContext::Private : public PropertyMapper return m_info->includeName; } private: - IncludeInfo *m_info; + const IncludeInfo *m_info; FileContext m_fileContext; SrcLangExt m_lang; }; -IncludeInfoContext::IncludeInfoContext(IncludeInfo *info,SrcLangExt lang) +IncludeInfoContext::IncludeInfoContext(const IncludeInfo *info,SrcLangExt lang) { p = new Private(info,lang); } @@ -1119,14 +1205,59 @@ TemplateVariant IncludeInfoContext::get(const char *n) const //------------------------------------------------------------------------ +//%% list IncludeInfoList[Class] : list of nested classes +class IncludeInfoListContext::Private : public GenericNodeListContext +{ + public: + Private(const QList &list,SrcLangExt lang) + { + QListIterator li(list); + IncludeInfo *ii; + for (li.toFirst();(ii=li.current());++li) + { + if (!ii->indirect) + { + append(new IncludeInfoContext(ii,lang)); + } + } + } +}; + +IncludeInfoListContext::IncludeInfoListContext(const QList &list,SrcLangExt lang) +{ + p = new Private(list,lang); +} + +IncludeInfoListContext::~IncludeInfoListContext() +{ + delete p; +} + +// TemplateListIntf +int IncludeInfoListContext::count() const +{ + return p->count(); +} + +TemplateVariant IncludeInfoListContext::at(int index) const +{ + return p->at(index); +} + +TemplateListIntf::ConstIterator *IncludeInfoListContext::createIterator() const +{ + return p->createIterator(); +} + +//------------------------------------------------------------------------ + //%% struct Class(Symbol): class information //%% { class ClassContext::Private : public DefinitionContext { public: - Private(ClassDef *cd) : DefinitionContext(cd) , - m_classDef(cd), m_usedFiles(cd), - m_includeInfo(cd ? cd->includeInfo() : 0, cd ? cd->getLanguage() : SrcLangExt_Unknown) + Private(ClassDef *cd) : DefinitionContext(cd), + m_classDef(cd), m_usedFiles(cd) { addProperty("title", this,&Private::title); addProperty("highlight", this,&Private::highlight); @@ -1139,7 +1270,6 @@ class ClassContext::Private : public DefinitionContext addProperty("hasCollaborationDiagram", this,&Private::hasCollaborationDiagram); addProperty("collaborationDiagram", this,&Private::collaborationDiagram); addProperty("includeInfo", this,&Private::includeInfo); - addProperty("includeStatement", this,&Private::includeStatement); addProperty("inherits", this,&Private::inherits); addProperty("inheritedBy", this,&Private::inheritedBy); addProperty("unoIDLServices", this,&Private::unoIDLServices); @@ -1182,7 +1312,7 @@ class ClassContext::Private : public DefinitionContext addProperty("detailedVariables", this,&Private::detailedVariables); addProperty("detailedProperties", this,&Private::detailedProperties); addProperty("detailedEvents", this,&Private::detailedEvents); - addProperty("nestedClasses", this,&Private::nestedClasses); + addProperty("classes", this,&Private::classes); addProperty("compoundType", this,&Private::compoundType); addProperty("templateDecls", this,&Private::templateDecls); addProperty("typeConstraints", this,&Private::typeConstraints); @@ -1317,19 +1447,19 @@ class ClassContext::Private : public DefinitionContext TemplateVariant includeInfo() const { - if (m_classDef->includeInfo()) + if (!m_cache.includeInfo && m_classDef->includeInfo()) + { + m_cache.includeInfo.reset(new IncludeInfoContext(m_classDef->includeInfo(),m_classDef->getLanguage())); + } + if (m_cache.includeInfo) { - return TemplateVariant(&m_includeInfo); + return m_cache.includeInfo.get(); } else { return TemplateVariant(FALSE); } } - TemplateVariant includeStatement() const - { - return m_classDef->includeStatement(); - } TemplateVariant inherits() const { if (!m_cache.inheritsList) @@ -1530,12 +1660,9 @@ class ClassContext::Private : public DefinitionContext { return getMemberList(m_cache.detailedEvents,MemberListType_eventMembers,theTranslator->trEventDocumentation(),TRUE); } - TemplateVariant nestedClasses() const + TemplateVariant classes() const { - static bool extractPrivate = Config_getBool("EXTRACT_PRIVATE"); - static bool hideUndocClasses = Config_getBool("HIDE_UNDOC_CLASSES"); - static bool extractLocalClasses = Config_getBool("EXTRACT_LOCAL_CLASSES"); - if (!m_cache.nestedClasses) + if (!m_cache.classes) { NestedClassListContext *classList = new NestedClassListContext; if (m_classDef->getClassSDict()) @@ -1544,20 +1671,15 @@ class ClassContext::Private : public DefinitionContext ClassDef *cd; for (sdi.toFirst();(cd=sdi.current());++sdi) { - bool linkable = cd->isLinkable(); - if (cd->name().find('@')==-1 && !cd->isExtension() && - (cd->protection()!=::Private || extractPrivate) && - (linkable || - (!hideUndocClasses && (!cd->isLocal() || extractLocalClasses))) - ) + if (cd->visibleInParentsDeclList()) { classList->append(cd); } } } - m_cache.nestedClasses.reset(classList); + m_cache.classes.reset(classList); } - return m_cache.nestedClasses.get(); + return m_cache.classes.get(); } TemplateVariant compoundType() const { @@ -1764,71 +1886,70 @@ class ClassContext::Private : public DefinitionContext private: ClassDef *m_classDef; UsedFilesContext m_usedFiles; - IncludeInfoContext m_includeInfo; struct Cachable { Cachable() : inheritanceNodes(-1) { templateArgList.setAutoDelete(TRUE); exampleList.setAutoDelete(TRUE); - allMembers.setAutoDelete(TRUE); } + ScopedPtr includeInfo; ScopedPtr inheritsList; ScopedPtr inheritedByList; ScopedPtr classGraph; ScopedPtr collaborationGraph; - ScopedPtr nestedClasses; - ScopedPtr publicTypes; - ScopedPtr publicMethods; - ScopedPtr publicStaticMethods; - ScopedPtr publicAttributes; - ScopedPtr publicStaticAttributes; - ScopedPtr publicSlots; - ScopedPtr protectedTypes; - ScopedPtr protectedMethods; - ScopedPtr protectedStaticMethods; - ScopedPtr protectedAttributes; - ScopedPtr protectedStaticAttributes; - ScopedPtr protectedSlots; - ScopedPtr privateTypes; - ScopedPtr privateMethods; - ScopedPtr privateStaticMethods; - ScopedPtr privateAttributes; - ScopedPtr privateStaticAttributes; - ScopedPtr privateSlots; - ScopedPtr packageTypes; - ScopedPtr packageMethods; - ScopedPtr packageStaticMethods; - ScopedPtr packageAttributes; - ScopedPtr packageStaticAttributes; - ScopedPtr unoIDLServices; - ScopedPtr unoIDLInterfaces; - ScopedPtr signals; - ScopedPtr properties; - ScopedPtr events; - ScopedPtr friends; - ScopedPtr related; - ScopedPtr detailedTypedefs; - ScopedPtr detailedEnums; - ScopedPtr detailedServices; - ScopedPtr detailedInterfaces; - ScopedPtr detailedConstructors; - ScopedPtr detailedMethods; - ScopedPtr detailedRelated; - ScopedPtr detailedVariables; - ScopedPtr detailedProperties; - ScopedPtr detailedEvents; + ScopedPtr classes; + ScopedPtr publicTypes; + ScopedPtr publicMethods; + ScopedPtr publicStaticMethods; + ScopedPtr publicAttributes; + ScopedPtr publicStaticAttributes; + ScopedPtr publicSlots; + ScopedPtr protectedTypes; + ScopedPtr protectedMethods; + ScopedPtr protectedStaticMethods; + ScopedPtr protectedAttributes; + ScopedPtr protectedStaticAttributes; + ScopedPtr protectedSlots; + ScopedPtr privateTypes; + ScopedPtr privateMethods; + ScopedPtr privateStaticMethods; + ScopedPtr privateAttributes; + ScopedPtr privateStaticAttributes; + ScopedPtr privateSlots; + ScopedPtr packageTypes; + ScopedPtr packageMethods; + ScopedPtr packageStaticMethods; + ScopedPtr packageAttributes; + ScopedPtr packageStaticAttributes; + ScopedPtr unoIDLServices; + ScopedPtr unoIDLInterfaces; + ScopedPtr signals; + ScopedPtr properties; + ScopedPtr events; + ScopedPtr friends; + ScopedPtr related; + ScopedPtr detailedTypedefs; + ScopedPtr detailedEnums; + ScopedPtr detailedServices; + ScopedPtr detailedInterfaces; + ScopedPtr detailedConstructors; + ScopedPtr detailedMethods; + ScopedPtr detailedRelated; + ScopedPtr detailedVariables; + ScopedPtr detailedProperties; + ScopedPtr detailedEvents; ScopedPtr memberGroups; - ScopedPtr allMembersList; - ScopedPtr typeConstraints; - ScopedPtr examples; - ScopedPtr templateDecls; + ScopedPtr allMembersList; + ScopedPtr typeConstraints; + ScopedPtr examples; + ScopedPtr templateDecls; ScopedPtr additionalInheritedMembers; - ScopedPtr members; - QList templateArgList; - int inheritanceNodes; - QList exampleList; - MemberList allMembers; + ScopedPtr members; + QList templateArgList; + int inheritanceNodes; + QList exampleList; + MemberList allMembers; }; mutable Cachable m_cache; }; @@ -1862,6 +1983,7 @@ class NamespaceContext::Private : public DefinitionContextcompoundTypeString(); + } private: NamespaceDef *m_namespaceDef; }; @@ -1904,10 +2030,34 @@ class FileContext::Private : public DefinitionContext public: Private(FileDef *fd) : DefinitionContext(fd) , m_fileDef(fd) { - addProperty("title",this,&Private::title); - addProperty("highlight",this,&Private::highlight); - addProperty("subhighlight",this,&Private::subHighlight); - addProperty("versionInfo",this,&Private::versionInfo); + addProperty("title", this,&Private::title); + addProperty("highlight", this,&Private::highlight); + addProperty("subhighlight", this,&Private::subHighlight); + addProperty("versionInfo", this,&Private::versionInfo); + addProperty("includeList", this,&Private::includeList); + addProperty("hasIncludeGraph", this,&Private::hasIncludeGraph); + addProperty("hasIncludedByGraph", this,&Private::hasIncludedByGraph); + addProperty("includeGraph", this,&Private::includeGraph); + addProperty("includedByGraph", this,&Private::includedByGraph); + addProperty("hasDetails", this,&Private::hasDetails); + addProperty("hasSourceFile", this,&Private::hasSourceFile); + addProperty("sources", this,&Private::sources); + addProperty("version", this,&Private::version); + addProperty("classes", this,&Private::classes); + addProperty("namespaces", this,&Private::namespaces); + addProperty("constantgroups", this,&Private::constantgroups); + addProperty("macros", this,&Private::macros); + addProperty("typedefs", this,&Private::typedefs); + addProperty("enums", this,&Private::enums); + addProperty("functions", this,&Private::functions); + addProperty("variables", this,&Private::variables); + addProperty("memberGroups", this,&Private::memberGroups); + addProperty("detailedMacros", this,&Private::detailedMacros); + addProperty("detailedTypedefs", this,&Private::detailedTypedefs); + addProperty("detailedEnums", this,&Private::detailedEnums); + addProperty("detailedFunctions", this,&Private::detailedFunctions); + addProperty("detailedVariables", this,&Private::detailedVariables); + addProperty("inlineClasses", this,&Private::inlineClasses); } TemplateVariant title() const { @@ -1925,8 +2075,302 @@ class FileContext::Private : public DefinitionContext { return m_fileDef->getVersion(); } + TemplateVariant includeList() const + { + if (!m_cache.includeInfoList && m_fileDef->includeFileList()) + { + m_cache.includeInfoList.reset(new IncludeInfoListContext( + *m_fileDef->includeFileList(),m_fileDef->getLanguage())); + } + if (m_cache.includeInfoList) + { + return m_cache.includeInfoList.get(); + } + else + { + return TemplateVariant(FALSE); + } + } + DotInclDepGraph *getIncludeGraph() const + { + if (!m_cache.includeGraph) + { + m_cache.includeGraph.reset(new DotInclDepGraph(m_fileDef,FALSE)); + } + return m_cache.includeGraph.get(); + } + TemplateVariant hasIncludeGraph() const + { + static bool haveDot = Config_getBool("HAVE_DOT"); + DotInclDepGraph *incGraph = getIncludeGraph(); + return (haveDot && !incGraph->isTooBig() && !incGraph->isTrivial()); + } + TemplateVariant includeGraph() const + { + static bool haveDot = Config_getBool("HAVE_DOT"); + QGString result; + if (haveDot) + { + DotInclDepGraph *cg = getIncludeGraph(); + FTextStream t(&result); + cg->writeGraph(t,BITMAP, + g_globals.outputDir, + g_globals.outputDir+portable_pathSeparator()+m_fileDef->getOutputFileBase()+Doxygen::htmlFileExtension, + relPathAsString(),TRUE,g_globals.dynSectionId + ); + } + g_globals.dynSectionId++; + return TemplateVariant(result.data(),TRUE); + } + DotInclDepGraph *getIncludedByGraph() const + { + if (!m_cache.includedByGraph) + { + m_cache.includedByGraph.reset(new DotInclDepGraph(m_fileDef,TRUE)); + } + return m_cache.includedByGraph.get(); + } + TemplateVariant hasIncludedByGraph() const + { + static bool haveDot = Config_getBool("HAVE_DOT"); + DotInclDepGraph *incGraph = getIncludedByGraph(); + return (haveDot && !incGraph->isTooBig() && !incGraph->isTrivial()); + } + TemplateVariant includedByGraph() const + { + static bool haveDot = Config_getBool("HAVE_DOT"); + QGString result; + if (haveDot) + { + DotInclDepGraph *cg = getIncludedByGraph(); + FTextStream t(&result); + cg->writeGraph(t,BITMAP, + g_globals.outputDir, + g_globals.outputDir+portable_pathSeparator()+m_fileDef->getOutputFileBase()+Doxygen::htmlFileExtension, + relPathAsString(),TRUE,g_globals.dynSectionId + ); + } + g_globals.dynSectionId++; + return TemplateVariant(result.data(),TRUE); + } + TemplateVariant hasDetails() const + { + return m_fileDef->hasDetailedDescription(); + } + TemplateVariant hasSourceFile() const + { + return m_fileDef->generateSourceFile(); + } + TemplateVariant sources() const + { + if (!m_cache.sources) + { + if (m_fileDef->generateSourceFile()) + { + m_cache.sources.reset(new TemplateVariant(parseCode(m_fileDef,relPathAsString()))); + } + else + { + m_cache.sources.reset(new TemplateVariant("")); + } + } + return *m_cache.sources; + } + TemplateVariant version() const + { + return m_fileDef->fileVersion(); + } + TemplateVariant classes() const + { + if (!m_cache.classes) + { + NestedClassListContext *classList = new NestedClassListContext; + if (m_fileDef->getClassSDict()) + { + ClassSDict::Iterator sdi(*m_fileDef->getClassSDict()); + ClassDef *cd; + for (sdi.toFirst();(cd=sdi.current());++sdi) + { + if (cd->visibleInParentsDeclList()) + { + classList->append(cd); + } + } + } + m_cache.classes.reset(classList); + } + return m_cache.classes.get(); + } + TemplateVariant namespaces() const + { + if (!m_cache.namespaces) + { + NestedNamespaceListContext *namespaceList = new NestedNamespaceListContext; + if (m_fileDef->getNamespaceSDict()) + { + NamespaceSDict::Iterator sdi(*m_fileDef->getNamespaceSDict()); + NamespaceDef *nd; + for (sdi.toFirst();(nd=sdi.current());++sdi) + { + if (nd->isLinkable() && !nd->isConstantGroup()) + { + namespaceList->append(nd); + } + } + } + m_cache.namespaces.reset(namespaceList); + } + return m_cache.namespaces.get(); + } + TemplateVariant constantgroups() const + { + if (!m_cache.constantgroups) + { + NestedNamespaceListContext *namespaceList = new NestedNamespaceListContext; + if (m_fileDef->getNamespaceSDict()) + { + NamespaceSDict::Iterator sdi(*m_fileDef->getNamespaceSDict()); + NamespaceDef *nd; + for (sdi.toFirst();(nd=sdi.current());++sdi) + { + if (nd->isLinkable() && nd->isConstantGroup()) + { + namespaceList->append(nd); + } + } + } + m_cache.constantgroups.reset(namespaceList); + } + return m_cache.constantgroups.get(); + } + TemplateVariant getMemberList(ScopedPtr &list, + MemberListType type,const char *title,bool detailed=FALSE) const + { + if (!list) + { + MemberList *ml = m_fileDef->getMemberList(type); + if (ml) + { + list.reset(new MemberListInfoContext(m_fileDef,relPathAsString(),ml,title,detailed)); + } + } + if (list) + { + return list.get(); + } + else + { + return TemplateVariant(FALSE); + } + } + TemplateVariant macros() const + { + return getMemberList(m_cache.macros,MemberListType_decDefineMembers,theTranslator->trDefines()); + } + TemplateVariant typedefs() const + { + return getMemberList(m_cache.typedefs,MemberListType_decTypedefMembers,theTranslator->trTypedefs()); + } + TemplateVariant enums() const + { + return getMemberList(m_cache.enums,MemberListType_decEnumMembers,theTranslator->trEnumerations()); + } + TemplateVariant functions() const + { + // TODO: Fortran: trSubprograms() + // TODO: VHDL: VhdlDocGen::trFunctionAndProc() + return getMemberList(m_cache.functions,MemberListType_decFuncMembers,theTranslator->trFunctions()); + } + TemplateVariant variables() const + { + return getMemberList(m_cache.variables,MemberListType_decVarMembers,theTranslator->trVariables()); + } + TemplateVariant memberGroups() const + { + if (!m_cache.memberGroups) + { + if (m_fileDef->getMemberGroupSDict()) + { + m_cache.memberGroups.reset(new MemberGroupListContext(m_fileDef,relPathAsString(),m_fileDef->getMemberGroupSDict(),m_fileDef->subGrouping())); + } + else + { + m_cache.memberGroups.reset(new MemberGroupListContext); + } + } + return m_cache.memberGroups.get(); + } + TemplateVariant detailedMacros() const + { + return getMemberList(m_cache.detailedMacros,MemberListType_docDefineMembers,theTranslator->trDefineDocumentation()); + } + TemplateVariant detailedTypedefs() const + { + return getMemberList(m_cache.detailedTypedefs,MemberListType_docTypedefMembers,theTranslator->trTypedefDocumentation()); + } + TemplateVariant detailedEnums() const + { + return getMemberList(m_cache.detailedEnums,MemberListType_docEnumMembers,theTranslator->trEnumerationTypeDocumentation()); + } + TemplateVariant detailedFunctions() const + { + // TODO: Fortran: trSubprogramDocumentation() + return getMemberList(m_cache.detailedFunctions,MemberListType_docFuncMembers,theTranslator->trFunctionDocumentation()); + } + TemplateVariant detailedVariables() const + { + return getMemberList(m_cache.detailedVariables,MemberListType_docVarMembers,theTranslator->trVariableDocumentation()); + } + TemplateVariant inlineClasses() const + { + if (!m_cache.inlineClasses) + { + NestedClassListContext *classList = new NestedClassListContext; + if (m_fileDef->getClassSDict()) + { + ClassSDict::Iterator sdi(*m_fileDef->getClassSDict()); + ClassDef *cd; + for (sdi.toFirst();(cd=sdi.current());++sdi) + { + if (cd->name().find('@')==-1 && + cd->isLinkableInProject() && + cd->isEmbeddedInOuterScope() && + cd->partOfGroups()==0) + { + classList->append(cd); + } + } + } + m_cache.inlineClasses.reset(classList); + } + return m_cache.inlineClasses.get(); + } + private: FileDef *m_fileDef; + struct Cachable + { + ScopedPtr includeInfoList; + ScopedPtr includeGraph; + ScopedPtr includedByGraph; + ScopedPtr sources; + ScopedPtr classes; + ScopedPtr namespaces; + ScopedPtr constantgroups; + ScopedPtr macros; + ScopedPtr typedefs; + ScopedPtr enums; + ScopedPtr functions; + ScopedPtr variables; + ScopedPtr memberGroups; + ScopedPtr detailedMacros; + ScopedPtr detailedTypedefs; + ScopedPtr detailedEnums; + ScopedPtr detailedFunctions; + ScopedPtr detailedVariables; + ScopedPtr inlineClasses; + }; + mutable Cachable m_cache; }; //%% } @@ -2160,21 +2604,70 @@ class MemberContext::Private : public DefinitionContext public: Private(MemberDef *md) : DefinitionContext(md) , m_memberDef(md) { - addProperty("declType", this,&Private::declType); - addProperty("declArgs", this,&Private::declArgs); + addProperty("isSignal", this,&Private::isSignal); + addProperty("isSlot", this,&Private::isSlot); + addProperty("isVariable", this,&Private::isVariable); + addProperty("isEnumeration", this,&Private::isEnumeration); + addProperty("isEnumValue", this,&Private::isEnumValue); + addProperty("isTypedef", this,&Private::isTypedef); + addProperty("isFunction", this,&Private::isFunction); + addProperty("isFunctionPtr", this,&Private::isFunctionPtr); + addProperty("isDefine", this,&Private::isDefine); + addProperty("isFriend", this,&Private::isFriend); + addProperty("isProperty", this,&Private::isProperty); + addProperty("isEvent", this,&Private::isEvent); + addProperty("isRelated", this,&Private::isRelated); + addProperty("isForeign", this,&Private::isForeign); addProperty("isStatic", this,&Private::isStatic); + addProperty("isInline", this,&Private::isInline); + addProperty("isExplicit", this,&Private::isExplicit); + addProperty("isMutable", this,&Private::isMutable); + addProperty("isGettable", this,&Private::isGettable); + addProperty("isSettable", this,&Private::isSettable); + addProperty("isReadable", this,&Private::isReadable); + addProperty("isWritable", this,&Private::isWritable); + addProperty("isAddable", this,&Private::isAddable); + addProperty("isRemovable", this,&Private::isRemovable); + addProperty("isRaisable", this,&Private::isRaisable); + addProperty("isFinal", this,&Private::isFinal); + addProperty("isAbstract", this,&Private::isAbstract); + addProperty("isOverride", this,&Private::isOverride); + addProperty("isInitonly", this,&Private::isInitonly); + addProperty("isOptional", this,&Private::isOptional); + addProperty("isRequired", this,&Private::isRequired); + addProperty("isNonAtomic", this,&Private::isNonAtomic); + addProperty("isCopy", this,&Private::isCopy); + addProperty("isAssign", this,&Private::isAssign); + addProperty("isRetain", this,&Private::isRetain); + addProperty("isWeak", this,&Private::isWeak); + addProperty("isStrong", this,&Private::isStrong); + addProperty("isUnretained", this,&Private::isUnretained); + addProperty("isNew", this,&Private::isNew); + addProperty("isSealed", this,&Private::isSealed); + addProperty("isImplementation", this,&Private::isImplementation); + addProperty("isExternal", this,&Private::isExternal); + addProperty("isAlias", this,&Private::isAlias); + addProperty("isDefault", this,&Private::isDefault); + addProperty("isDelete", this,&Private::isDelete); + addProperty("isNoExcept", this,&Private::isNoExcept); + addProperty("isAttribute", this,&Private::isAttribute); + addProperty("isUNOProperty", this,&Private::isUNOProperty); + addProperty("isReadonly", this,&Private::isReadonly); + addProperty("isBound", this,&Private::isBound); + addProperty("isConstrained", this,&Private::isConstrained); + addProperty("isTransient", this,&Private::isTransient); + addProperty("isMaybeVoid", this,&Private::isMaybeVoid); + addProperty("isMaybeDefault", this,&Private::isMaybeDefault); + addProperty("isMaybeAmbiguous", this,&Private::isMaybeAmbiguous); + addProperty("isPublished", this,&Private::isPublished); + addProperty("isTemplateSpecialization",this,&Private::isTemplateSpecialization); addProperty("isObjCMethod", this,&Private::isObjCMethod); addProperty("isObjCProperty", this,&Private::isObjCProperty); - addProperty("isDefine", this,&Private::isDefine); - addProperty("isImplementation", this,&Private::isImplementation); - addProperty("isEvent", this,&Private::isEvent); - addProperty("isProperty", this,&Private::isProperty); - addProperty("isEnumeration", this,&Private::isEnumeration); - addProperty("isEnumValue", this,&Private::isEnumValue); addProperty("isAnonymous", this,&Private::isAnonymous); + addProperty("declType", this,&Private::declType); + addProperty("declArgs", this,&Private::declArgs); addProperty("anonymousType", this,&Private::anonymousType); addProperty("anonymousMember", this,&Private::anonymousMember); - addProperty("isRelated", this,&Private::isRelated); addProperty("hasDetails", this,&Private::hasDetails); addProperty("exception", this,&Private::exception); addProperty("bitfields", this,&Private::bitfields); @@ -2214,6 +2707,7 @@ class MemberContext::Private : public DefinitionContext addProperty("callGraph", this,&Private::callGraph); addProperty("hasCallerGraph", this,&Private::hasCallerGraph); addProperty("callerGraph", this,&Private::callerGraph); + addProperty("fieldType", this,&Private::fieldType); if (md && md->isProperty()) { @@ -2227,6 +2721,10 @@ class MemberContext::Private : public DefinitionContext if (md->isRaisable()) m_eventAttrs.append("raise"); } } + TemplateVariant fieldType() const + { + return createLinkedText(m_memberDef,relPathAsString(),m_memberDef->fieldType()); + } TemplateVariant declType() const { return createLinkedText(m_memberDef,relPathAsString(),m_memberDef->getDeclType()); @@ -2259,10 +2757,202 @@ class MemberContext::Private : public DefinitionContext { return m_memberDef->isImplementation(); } + TemplateVariant isSignal() const + { + return m_memberDef->isSignal(); + } + TemplateVariant isSlot() const + { + return m_memberDef->isSlot(); + } + TemplateVariant isTypedef() const + { + return m_memberDef->isTypedef(); + } + TemplateVariant isFunction() const + { + return m_memberDef->isFunction(); + } + TemplateVariant isFunctionPtr() const + { + return m_memberDef->isFunctionPtr(); + } + TemplateVariant isFriend() const + { + return m_memberDef->isFriend(); + } + TemplateVariant isForeign() const + { + return m_memberDef->isForeign(); + } TemplateVariant isEvent() const { return m_memberDef->isEvent(); } + TemplateVariant isInline() const + { + return m_memberDef->isInline(); + } + TemplateVariant isExplicit() const + { + return m_memberDef->isExplicit(); + } + TemplateVariant isMutable() const + { + return m_memberDef->isMutable(); + } + TemplateVariant isGettable() const + { + return m_memberDef->isSettable(); + } + TemplateVariant isSettable() const + { + return m_memberDef->isSettable(); + } + TemplateVariant isReadable() const + { + return m_memberDef->isReadable(); + } + TemplateVariant isWritable() const + { + return m_memberDef->isWritable(); + } + TemplateVariant isAddable() const + { + return m_memberDef->isAddable(); + } + TemplateVariant isRemovable() const + { + return m_memberDef->isRemovable(); + } + TemplateVariant isRaisable() const + { + return m_memberDef->isRaisable(); + } + TemplateVariant isFinal() const + { + return m_memberDef->isFinal(); + } + TemplateVariant isAbstract() const + { + return m_memberDef->isAbstract(); + } + TemplateVariant isOverride() const + { + return m_memberDef->isOverride(); + } + TemplateVariant isInitonly() const + { + return m_memberDef->isInitonly(); + } + TemplateVariant isOptional() const + { + return m_memberDef->isOptional(); + } + TemplateVariant isRequired() const + { + return m_memberDef->isRequired(); + } + TemplateVariant isNonAtomic() const + { + return m_memberDef->isNonAtomic(); + } + TemplateVariant isCopy() const + { + return m_memberDef->isCopy(); + } + TemplateVariant isAssign() const + { + return m_memberDef->isAssign(); + } + TemplateVariant isRetain() const + { + return m_memberDef->isRetain(); + } + TemplateVariant isWeak() const + { + return m_memberDef->isWeak(); + } + TemplateVariant isStrong() const + { + return m_memberDef->isStrong(); + } + TemplateVariant isUnretained() const + { + return m_memberDef->isUnretained(); + } + TemplateVariant isNew() const + { + return m_memberDef->isNew(); + } + TemplateVariant isSealed() const + { + return m_memberDef->isSealed(); + } + TemplateVariant isExternal() const + { + return m_memberDef->isExternal(); + } + TemplateVariant isAlias() const + { + return m_memberDef->isAlias(); + } + TemplateVariant isDefault() const + { + return m_memberDef->isDefault(); + } + TemplateVariant isDelete() const + { + return m_memberDef->isDelete(); + } + TemplateVariant isNoExcept() const + { + return m_memberDef->isNoExcept(); + } + TemplateVariant isAttribute() const + { + return m_memberDef->isAttribute(); + } + TemplateVariant isUNOProperty() const + { + return m_memberDef->isUNOProperty(); + } + TemplateVariant isReadonly() const + { + return m_memberDef->isReadonly(); + } + TemplateVariant isBound() const + { + return m_memberDef->isBound(); + } + TemplateVariant isConstrained() const + { + return m_memberDef->isConstrained(); + } + TemplateVariant isTransient() const + { + return m_memberDef->isTransient(); + } + TemplateVariant isMaybeVoid() const + { + return m_memberDef->isMaybeVoid(); + } + TemplateVariant isMaybeDefault() const + { + return m_memberDef->isMaybeDefault(); + } + TemplateVariant isMaybeAmbiguous() const + { + return m_memberDef->isMaybeAmbiguous(); + } + TemplateVariant isPublished() const + { + return m_memberDef->isPublished(); + } + TemplateVariant isTemplateSpecialization() const + { + return m_memberDef->isTemplateSpecialization(); + } TemplateVariant isProperty() const { return m_memberDef->isProperty(); @@ -2271,6 +2961,10 @@ class MemberContext::Private : public DefinitionContext { return m_memberDef->isEnumValue(); } + TemplateVariant isVariable() const + { + return m_memberDef->isVariable(); + } TemplateVariant isEnumeration() const { return m_memberDef->isEnumerate(); @@ -2717,10 +3411,10 @@ class MemberContext::Private : public DefinitionContext TemplateVariant functionQualifier() const { if (!m_memberDef->isObjCMethod() && - (m_memberDef->isFunction() || m_memberDef->isSlot() || + (m_memberDef->isFunction() || m_memberDef->isSlot() || m_memberDef->isPrototype() || m_memberDef->isSignal() ) - ) + ) { return "()"; } @@ -3007,6 +3701,47 @@ void NestedClassListContext::append(ClassDef *cd) //------------------------------------------------------------------------ +//%% list NestedClassList[Class] : list of nested namespaces +class NestedNamespaceListContext::Private : public GenericNodeListContext +{ +}; + +NestedNamespaceListContext::NestedNamespaceListContext() +{ + p = new Private; +} + +NestedNamespaceListContext::~NestedNamespaceListContext() +{ + delete p; +} + +// TemplateListIntf +int NestedNamespaceListContext::count() const +{ + return p->count(); +} + +TemplateVariant NestedNamespaceListContext::at(int index) const +{ + return p->at(index); +} + +TemplateListIntf::ConstIterator *NestedNamespaceListContext::createIterator() const +{ + return p->createIterator(); +} + +void NestedNamespaceListContext::append(NamespaceDef *cd) +{ + if (cd) + { + p->append(new NamespaceContext(cd)); + } +} + +//------------------------------------------------------------------------ + //%% list ClassList[Class] : list of classes class ClassListContext::Private : public GenericNodeListContext { @@ -5744,7 +6479,7 @@ void generateOutputViaTemplate() ctx->set("exampleList",&exampleList); // render HTML output - Template *tpl = e.loadByName("htmllayout.tpl"); + Template *tpl = e.loadByName("htmllayout.tpl",1); if (tpl) { g_globals.outputFormat = ContextGlobals::Html; @@ -5758,6 +6493,7 @@ void generateOutputViaTemplate() FTextStream ts; tpl->render(ts,ctx); } + e.unload(tpl); // TODO: render other outputs } diff --git a/src/context.h b/src/context.h index f027749..7506471 100644 --- a/src/context.h +++ b/src/context.h @@ -3,6 +3,7 @@ #include "types.h" #include "template.h" +#include class Definition; class ClassDef; @@ -108,7 +109,7 @@ class UsedFilesContext : public TemplateListIntf class IncludeInfoContext : public TemplateStructIntf { public: - IncludeInfoContext(IncludeInfo *,SrcLangExt lang); + IncludeInfoContext(const IncludeInfo *,SrcLangExt lang); ~IncludeInfoContext(); // TemplateStructIntf methods @@ -121,6 +122,25 @@ class IncludeInfoContext : public TemplateStructIntf //---------------------------------------------------- +class IncludeInfoListContext : public TemplateListIntf +{ + public: + IncludeInfoListContext(const QList &list,SrcLangExt lang); + ~IncludeInfoListContext(); + + // TemplateListIntf + virtual int count() const; + virtual TemplateVariant at(int index) const; + virtual TemplateListIntf::ConstIterator *createIterator() const; + + private: + class Private; + Private *p; +}; + + +//---------------------------------------------------- + class ClassContext : public TemplateStructIntf { public: @@ -254,6 +274,26 @@ class NestedClassListContext : public TemplateListIntf //---------------------------------------------------- +class NestedNamespaceListContext : public TemplateListIntf +{ + public: + NestedNamespaceListContext(); + ~NestedNamespaceListContext(); + + // TemplateListIntf + virtual int count() const; + virtual TemplateVariant at(int index) const; + virtual TemplateListIntf::ConstIterator *createIterator() const; + + void append(NamespaceDef *cd); + + private: + class Private; + Private *p; +}; + +//---------------------------------------------------- + class ClassListContext : public TemplateListIntf { public: diff --git a/src/filedef.cpp b/src/filedef.cpp index e286284..1368628 100644 --- a/src/filedef.cpp +++ b/src/filedef.cpp @@ -170,12 +170,18 @@ void FileDef::findSectionsInDocumentation() } } +bool FileDef::hasDetailedDescription() const +{ + static bool sourceBrowser = Config_getBool("SOURCE_BROWSER"); + return ((!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF")) || + !documentation().stripWhiteSpace().isEmpty() || // avail empty section + (sourceBrowser && getStartBodyLine()!=-1 && getBodyDef()) + ); +} + void FileDef::writeDetailedDescription(OutputList &ol,const QCString &title) { - if ((!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF")) || - !documentation().stripWhiteSpace().isEmpty() || // avail empty section - (Config_getBool("SOURCE_BROWSER") && getStartBodyLine()!=-1 && getBodyDef()) - ) + if (hasDetailedDescription()) { ol.pushGeneratorState(); ol.disable(OutputGenerator::Html); @@ -379,7 +385,7 @@ void FileDef::writeIncludedByGraph(OutputList &ol) { warn_uncond("Included by graph for '%s' not generated, too many nodes. Consider increasing DOT_GRAPH_MAX_NODES.\n",name().data()); } - if (!incDepGraph.isTrivial()) + else if (!incDepGraph.isTrivial()) { ol.startTextBlock(); ol.disable(OutputGenerator::Man); @@ -1800,3 +1806,7 @@ QCString FileDef::title() const return theTranslator->trFileReference(name()); } +QCString FileDef::fileVersion() const +{ + return m_fileVersion; +} diff --git a/src/filedef.h b/src/filedef.h index d1d7496..58b17bd 100644 --- a/src/filedef.h +++ b/src/filedef.h @@ -133,6 +133,10 @@ class FileDef : public Definition ClassSDict *getClassSDict() const { return m_classSDict; } QCString title() const; + bool hasDetailedDescription() const; + QCString fileVersion() const; + + bool subGrouping() const { return m_subGrouping; } //--------------------------------- diff --git a/src/memberdef.cpp b/src/memberdef.cpp index 4d7ea9f..d2964d4 100644 --- a/src/memberdef.cpp +++ b/src/memberdef.cpp @@ -3036,6 +3036,18 @@ static Definition *getClassFromType(Definition *scope,const QCString &type,SrcLa } #endif +QCString MemberDef::fieldType() const +{ + QCString type = m_impl->accessorType; + if (type.isEmpty()) + { + type = m_impl->type; + } + + if (isTypedef()) type.prepend("typedef "); + return simplifyTypeForTable(type); +} + void MemberDef::writeMemberDocSimple(OutputList &ol, Definition *container) { Definition *scope = getOuterScope(); @@ -3056,15 +3068,7 @@ void MemberDef::writeMemberDocSimple(OutputList &ol, Definition *container) ol.startInlineMemberType(); ol.startDoxyAnchor(cfname,cname,memAnchor,doxyName,doxyArgs); - QCString type = m_impl->accessorType; - if (type.isEmpty()) - { - type = m_impl->type; - } - - if (isTypedef()) type.prepend("typedef "); - - QCString ts = simplifyTypeForTable(type); + QCString ts = fieldType(); if (cd) // cd points to an anonymous struct pointed to by this member // so we add a link to it from the type column. @@ -3855,6 +3859,11 @@ void MemberDef::setAccessorType(ClassDef *cd,const char *t) m_impl->accessorType = t; } +ClassDef *MemberDef::accessorClass() const +{ + return m_impl->accessorClass; +} + void MemberDef::findSectionsInDocumentation() { docFindSections(documentation(),this,0,docFile()); diff --git a/src/memberdef.h b/src/memberdef.h index 47912b8..dffd53c 100644 --- a/src/memberdef.h +++ b/src/memberdef.h @@ -81,6 +81,7 @@ class MemberDef : public Definition ClassDef *getClassDef() const; FileDef *getFileDef() const; NamespaceDef* getNamespaceDef() const; + ClassDef *accessorClass() const; // grabbing the property read/write accessor names const char *getReadAccessor() const; @@ -251,7 +252,7 @@ class MemberDef : public Definition // overrules QCString documentation() const; QCString briefDescription(bool abbr=FALSE) const; - + QCString fieldType() const; //----------------------------------------------------------------------------------- diff --git a/src/message.cpp b/src/message.cpp index dd3549a..ff5dac2 100644 --- a/src/message.cpp +++ b/src/message.cpp @@ -13,7 +13,6 @@ * */ -#include #include #include #include "config.h" @@ -22,6 +21,7 @@ #include "doxygen.h" #include "portable.h" #include "filedef.h" +#include "message.h" static QCString outputFormat; static const char *warning_str = "warning: "; @@ -110,7 +110,7 @@ void msg(const char *fmt, ...) va_list args; va_start(args, fmt); vfprintf(stdout, fmt, args); - va_end(args); + va_end(args); } } @@ -172,6 +172,11 @@ void warn(const char *file,int line,const char *fmt, ...) va_end(args); } +void warn(const char *file,int line,const char *fmt,va_list args) +{ + do_warn("WARNINGS", file, line, warning_str, fmt, args); +} + void warn_simple(const char *file,int line,const char *text) { if (!Config_getBool("WARNINGS")) return; // warning type disabled diff --git a/src/message.h b/src/message.h index b7bdfe4..2875e81 100644 --- a/src/message.h +++ b/src/message.h @@ -19,9 +19,11 @@ #define MESSAGE_H #include +#include extern void msg(const char *fmt, ...); extern void warn(const char *file,int line,const char *fmt, ...); +extern void warn(const char *file,int line,const char *fmt, va_list args); extern void warn_simple(const char *file,int line,const char *text); extern void warn_undoc(const char *file,int line,const char *fmt, ...); extern void warn_doc_error(const char *file,int line,const char *fmt, ...); diff --git a/src/namespacedef.cpp b/src/namespacedef.cpp index d00d845..c39b38f 100644 --- a/src/namespacedef.cpp +++ b/src/namespacedef.cpp @@ -916,29 +916,9 @@ void NamespaceSDict::writeDeclaration(OutputList &ol,const char *title, continue; // will be output in another pass, see layout_default.xml ol.startMemberDeclaration(); ol.startMemberItem(nd->getOutputFileBase(),0); - if (lang==SrcLangExt_Java || lang==SrcLangExt_CSharp) - { - ol.docify("package "); - } - else if (lang==SrcLangExt_Fortran) - { - ol.docify("module "); - } - else if (lang==SrcLangExt_IDL) - { - if (nd->isModule()) - { - ol.docify("module "); - } - else if (nd->isConstantGroup()) - { - ol.docify("constants"); - } - else - { - err("Internal inconsistency: namespace in IDL not module or cg\n"); - } - } + QCString ct = nd->compoundTypeString(); + ol.docify(ct); + ol.docify(" "); ol.insertMemberAlign(); QCString name; if (localName) @@ -1103,3 +1083,33 @@ QCString NamespaceDef::title() const } return pageTitle; } + +QCString NamespaceDef::compoundTypeString() const +{ + SrcLangExt lang = getLanguage(); + if (lang==SrcLangExt_Java || lang==SrcLangExt_CSharp) + { + return "package"; + } + else if (lang==SrcLangExt_Fortran) + { + return "module"; + } + else if (lang==SrcLangExt_IDL) + { + if (isModule()) + { + return "module"; + } + else if (isConstantGroup()) + { + return "constants"; + } + else + { + err("Internal inconsistency: namespace in IDL not module or constant group\n"); + } + } + return ""; +} + diff --git a/src/namespacedef.h b/src/namespacedef.h index 2037d23..2fe5e4a 100644 --- a/src/namespacedef.h +++ b/src/namespacedef.h @@ -94,6 +94,7 @@ class NamespaceDef : public Definition NamespaceSDict *getNamespaceSDict() const { return namespaceSDict; } QCString title() const; + QCString compoundTypeString() const; bool visited; diff --git a/src/template.cpp b/src/template.cpp index 8144afd..af15a47 100644 --- a/src/template.cpp +++ b/src/template.cpp @@ -29,7 +29,8 @@ class TemplateToken; //------------------------------------------------------------------- -static QValueList split(const QCString &str,const QCString &sep,bool allowEmptyEntries=FALSE,bool cleanup=TRUE) +static QValueList split(const QCString &str,const QCString &sep, + bool allowEmptyEntries=FALSE,bool cleanup=TRUE) { QValueList lst; @@ -561,7 +562,7 @@ class TemplateBlockContext class TemplateContextImpl : public TemplateContext { public: - TemplateContextImpl(); + TemplateContextImpl(const TemplateEngine *e); virtual ~TemplateContextImpl(); // TemplateContext methods @@ -589,8 +590,10 @@ class TemplateContextImpl : public TemplateContext TemplateSpacelessIntf *spacelessIntf() const { return m_spacelessIntf; } void enableSpaceless(bool b) { m_spacelessEnabled=b; } bool spacelessEnabled() const { return m_spacelessEnabled && m_spacelessIntf; } + void warn(const char *fileName,int line,const char *fmt,...) const; private: + const TemplateEngine *m_engine; QCString m_templateName; int m_line; QCString m_outputDir; @@ -874,7 +877,7 @@ class ExprAstVariable : public ExprAst TemplateVariant v = c->get(m_name); if (!v.isValid()) { - warn(ci->templateName(),ci->line(),"undefined variable '%s' in expression",m_name.data()); + ci->warn(ci->templateName(),ci->line(),"undefined variable '%s' in expression",m_name.data()); } return v; } @@ -928,7 +931,7 @@ class ExprAstFilter : public ExprAst TemplateVariant result = TemplateFilterFactory::instance()->apply(m_name,v,arg,ok); if (!ok) { - warn(ci->templateName(),ci->line(),"unknown filter '%s'",m_name.data()); + ci->warn(ci->templateName(),ci->line(),"unknown filter '%s'",m_name.data()); } return result; } @@ -1047,6 +1050,46 @@ class ExprAstBinary : public ExprAst ExprAst *m_rhs; }; +//---------------------------------------------------------- + +/** @brief Base class of all nodes in a template's AST */ +class TemplateNode +{ + public: + TemplateNode(TemplateNode *parent) : m_parent(parent) {} + virtual ~TemplateNode() {} + + virtual void render(FTextStream &ts, TemplateContext *c) = 0; + + TemplateNode *parent() { return m_parent; } + + private: + TemplateNode *m_parent; +}; + +//---------------------------------------------------------- + +/** @brief Parser for templates */ +class TemplateParser +{ + public: + TemplateParser(const TemplateEngine *engine, + const QCString &templateName,QList &tokens); + void parse(TemplateNode *parent,int line,const QStrList &stopAt, + QList &nodes); + bool hasNextToken() const; + TemplateToken *takeNextToken(); + void removeNextToken(); + void prependToken(const TemplateToken *token); + const TemplateToken *currentToken() const; + QCString templateName() const { return m_templateName; } + void warn(const char *fileName,int line,const char *fmt,...) const; + private: + const TemplateEngine *m_engine; + QCString m_templateName; + QList &m_tokens; +}; + //-------------------------------------------------------------------- /** @brief Recursive decent parser for Django style template expressions. @@ -1054,8 +1097,8 @@ class ExprAstBinary : public ExprAst class ExpressionParser { public: - ExpressionParser(const QCString &templateName,int line) - : m_templateName(templateName), m_line(line), m_tokenStream(0) + ExpressionParser(const TemplateParser *parser,int line) + : m_parser(parser), m_line(line), m_tokenStream(0) { } virtual ~ExpressionParser() @@ -1153,7 +1196,7 @@ class ExpressionParser ExprAst *expr = parseCompareExpression(); if (expr==0) { - warn(m_templateName,m_line,"argument missing for not operator"); + warn(m_parser->templateName(),m_line,"argument missing for not operator"); return 0; } result = new ExprAstNegate(expr); @@ -1210,12 +1253,12 @@ class ExpressionParser default: if (m_curToken.type==ExprToken::Operator) { - warn(m_templateName,m_line,"unexpected operator '%s' in expression", + warn(m_parser->templateName(),m_line,"unexpected operator '%s' in expression", Operator::toString(m_curToken.op)); } else { - warn(m_templateName,m_line,"unexpected token in expression"); + warn(m_parser->templateName(),m_line,"unexpected token in expression"); } } TRACE(("}parsePrimary(%s)\n",m_tokenStream)); @@ -1461,7 +1504,7 @@ class ExpressionParser char s[2]; s[0]=c; s[1]=0; - warn(m_templateName,m_line,"Found unknown token %s while parsing %s",s,m_tokenStream); + warn(m_parser->templateName(),m_line,"Found unknown token %s while parsing %s",s,m_tokenStream); m_curToken.id = s; p++; } @@ -1472,51 +1515,14 @@ class ExpressionParser return TRUE; } + const TemplateParser *m_parser; ExprToken m_curToken; - QCString m_templateName; int m_line; const char *m_tokenStream; }; //---------------------------------------------------------- -/** @brief Base class of all nodes in a template's AST */ -class TemplateNode -{ - public: - TemplateNode(TemplateNode *parent) : m_parent(parent) {} - virtual ~TemplateNode() {} - - virtual void render(FTextStream &ts, TemplateContext *c) = 0; - - TemplateNode *parent() { return m_parent; } - - private: - TemplateNode *m_parent; -}; - -//---------------------------------------------------------- - -/** @brief Parser for templates */ -class TemplateParser -{ - public: - TemplateParser(const QCString &templateName,QList &tokens); - void parse(TemplateNode *parent,int line,const QStrList &stopAt, - QList &nodes); - bool hasNextToken() const; - TemplateToken *takeNextToken(); - void removeNextToken(); - void prependToken(const TemplateToken *token); - const TemplateToken *currentToken() const; - QCString templateName() const { return m_templateName; } - private: - QCString m_templateName; - QList &m_tokens; -}; - -//---------------------------------------------------------- - /** @brief Class representing a lexical token in a template */ class TemplateToken { @@ -1558,24 +1564,23 @@ class TemplateImpl : public TemplateNode, public Template { public: TemplateImpl(TemplateEngine *e,const QCString &name,const QCString &data); - ~TemplateImpl() {} void render(FTextStream &ts, TemplateContext *c); TemplateEngine *engine() const { return m_engine; } TemplateBlockContext *blockContext() { return &m_blockContext; } private: + TemplateEngine *m_engine; QCString m_name; TemplateNodeList m_nodes; - TemplateEngine *m_engine; TemplateBlockContext m_blockContext; }; //---------------------------------------------------------- -TemplateContextImpl::TemplateContextImpl() - : m_templateName(""), m_line(1), m_escapeIntf(0), +TemplateContextImpl::TemplateContextImpl(const TemplateEngine *e) + : m_engine(e), m_templateName(""), m_line(1), m_escapeIntf(0), m_spacelessIntf(0), m_spacelessEnabled(FALSE) { m_contextStack.setAutoDelete(TRUE); @@ -1704,6 +1709,15 @@ TemplateBlockContext *TemplateContextImpl::blockContext() return &m_blockContext; } +void TemplateContextImpl::warn(const char *fileName,int line,const char *fmt,...) const +{ + va_list args; + va_start(args,fmt); + ::warn(fileName,line,fmt,args); + va_end(args); + m_engine->printIncludeContext(fileName,line); +} + //---------------------------------------------------------- /** @brief Class representing a piece of plain text in a template */ @@ -1743,7 +1757,7 @@ class TemplateNodeVariable : public TemplateNode : TemplateNode(parent), m_templateName(parser->templateName()), m_line(line) { TRACE(("TemplateNodeVariable(%s)\n",var.data())); - ExpressionParser expParser(m_templateName,line); + ExpressionParser expParser(parser,line); m_var = expParser.parseVariable(var); } ~TemplateNodeVariable() @@ -1821,14 +1835,14 @@ class TemplateNodeIf : public TemplateNodeCreator TRACE(("{TemplateNodeIf(%s)\n",data.data())); if (data.isEmpty()) { - warn(m_templateName,line,"missing argument for if tag"); + parser->warn(m_templateName,line,"missing argument for if tag"); } QStrList stopAt; stopAt.append("endif"); stopAt.append("else"); parser->parse(this,line,stopAt,m_trueNodes); TemplateToken *tok = parser->takeNextToken(); - ExpressionParser ex(parser->templateName(),line); + ExpressionParser ex(parser,line); m_guardAst = ex.parse(data); if (tok && tok->data=="else") @@ -1847,7 +1861,8 @@ class TemplateNodeIf : public TemplateNodeCreator void render(FTextStream &ts, TemplateContext *c) { - dynamic_cast(c)->setLocation(m_templateName,m_line); + TemplateContextImpl* ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); //printf("TemplateNodeIf::render #trueNodes=%d #falseNodes=%d\n",m_trueNodes.count(),m_falseNodes.count()); if (m_guardAst) { @@ -1877,7 +1892,7 @@ class TemplateNodeRepeat : public TemplateNodeCreator : TemplateNodeCreator(parser,parent,line) { TRACE(("{TemplateNodeRepeat(%s)\n",data.data())); - ExpressionParser expParser(parser->templateName(),line); + ExpressionParser expParser(parser,line); m_expr = expParser.parseVariable(data); QStrList stopAt; stopAt.append("endrepeat"); @@ -1891,7 +1906,8 @@ class TemplateNodeRepeat : public TemplateNodeCreator } void render(FTextStream &ts, TemplateContext *c) { - dynamic_cast(c)->setLocation(m_templateName,m_line); + TemplateContextImpl* ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); TemplateVariant v; if (m_expr && (v=m_expr->resolve(c)).type()==TemplateVariant::Integer) { @@ -1912,7 +1928,7 @@ class TemplateNodeRepeat : public TemplateNodeCreator } else // simple type... { - warn(m_templateName,m_line,"for requires a variable of list type!"); + ci->warn(m_templateName,m_line,"for requires a variable of list type!"); } } private: @@ -1936,15 +1952,15 @@ class TemplateNodeFor : public TemplateNodeCreator { if (data.right(3)==" in") { - warn(m_templateName,line,"for is missing container after 'in' keyword"); + parser->warn(m_templateName,line,"for is missing container after 'in' keyword"); } else if (data=="in") { - warn(m_templateName,line,"for needs at least one iterator variable"); + parser->warn(m_templateName,line,"for needs at least one iterator variable"); } else { - warn(m_templateName,line,"for is missing 'in' keyword"); + parser->warn(m_templateName,line,"for is missing 'in' keyword"); } } else @@ -1952,7 +1968,7 @@ class TemplateNodeFor : public TemplateNodeCreator m_vars = split(data.left(i),","); if (m_vars.count()==0) { - warn(m_templateName,line,"for needs at least one iterator variable"); + parser->warn(m_templateName,line,"for needs at least one iterator variable"); } int j = data.find(" reversed",i); @@ -1965,10 +1981,10 @@ class TemplateNodeFor : public TemplateNodeCreator } if (exprStr.isEmpty()) { - warn(m_templateName,line,"for is missing container after 'in' keyword"); + parser->warn(m_templateName,line,"for is missing container after 'in' keyword"); } } - ExpressionParser expParser(parser->templateName(),line); + ExpressionParser expParser(parser,line); m_expr = expParser.parseVariable(exprStr); QStrList stopAt; @@ -1993,7 +2009,8 @@ class TemplateNodeFor : public TemplateNodeCreator void render(FTextStream &ts, TemplateContext *c) { - dynamic_cast(c)->setLocation(m_templateName,m_line); + TemplateContextImpl* ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); //printf("TemplateNodeFor::render #loopNodes=%d #emptyNodes=%d\n", // m_loopNodes.count(),m_emptyNodes.count()); if (m_expr) @@ -2058,7 +2075,7 @@ class TemplateNodeFor : public TemplateNodeCreator } else // simple type... { - warn(m_templateName,m_line,"for requires a variable of list type!"); + ci->warn(m_templateName,m_line,"for requires a variable of list type!"); } } } @@ -2090,6 +2107,7 @@ class TemplateNodeMsg : public TemplateNodeCreator void render(FTextStream &, TemplateContext *c) { TemplateContextImpl* ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); TemplateEscapeIntf *escIntf = ci->escapeIntf(); ci->setEscapeIntf(0); // avoid escaping things we send to standard out bool enable = ci->spacelessEnabled(); @@ -2118,7 +2136,7 @@ class TemplateNodeBlock : public TemplateNodeCreator m_blockName = data; if (m_blockName.isEmpty()) { - warn(parser->templateName(),line,"block tag without name"); + parser->warn(parser->templateName(),line,"block tag without name"); } QStrList stopAt; stopAt.append("endblock"); @@ -2156,14 +2174,18 @@ class TemplateNodeBlock : public TemplateNodeCreator superBlock.set("super",TemplateVariant(super.data(),TRUE)); ci->set("block",&superBlock); // render the overruled block contents + t->engine()->enterBlock(nb->m_templateName,nb->m_blockName,nb->m_line); nb->m_nodes.render(ts,c); + t->engine()->leaveBlock(); ci->pop(); // re-add block to the context ci->blockContext()->push(nb); } else // block has no overrule { + t->engine()->enterBlock(m_templateName,m_blockName,m_line); m_nodes.render(ts,c); + t->engine()->leaveBlock(); } } } @@ -2188,10 +2210,10 @@ class TemplateNodeExtend : public TemplateNodeCreator : TemplateNodeCreator(parser,parent,line) { TRACE(("{TemplateNodeExtend(%s)\n",data.data())); - ExpressionParser ep(m_templateName,line); + ExpressionParser ep(parser,line); if (data.isEmpty()) { - warn(m_templateName,line,"extend tag is missing template file argument"); + parser->warn(m_templateName,line,"extend tag is missing template file argument"); } m_extendExpr = ep.parsePrimary(data); QStrList stopAt; @@ -2205,20 +2227,21 @@ class TemplateNodeExtend : public TemplateNodeCreator void render(FTextStream &ts, TemplateContext *c) { - dynamic_cast(c)->setLocation(m_templateName,m_line); + TemplateContextImpl* ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); if (m_extendExpr==0) return; QCString extendFile = m_extendExpr->resolve(c).toString(); if (extendFile.isEmpty()) { - warn(m_templateName,m_line,"invalid parameter for extend command"); + ci->warn(m_templateName,m_line,"invalid parameter for extend command"); } // goto root of tree (template node) TemplateImpl *t = getTemplate(); if (t) { - Template *bt = t->engine()->loadByName(extendFile); + Template *bt = t->engine()->loadByName(extendFile,m_line); TemplateImpl *baseTemplate = bt ? dynamic_cast(bt) : 0; if (baseTemplate) { @@ -2248,11 +2271,11 @@ class TemplateNodeExtend : public TemplateNodeCreator // clean up bc->clear(); - //delete baseTemplate; + t->engine()->unload(t); } else { - warn(m_templateName,m_line,"failed to load template %s for extend",extendFile.data()); + ci->warn(m_templateName,m_line,"failed to load template %s for extend",extendFile.data()); } } } @@ -2270,10 +2293,10 @@ class TemplateNodeInclude : public TemplateNodeCreator : TemplateNodeCreator(parser,parent,line) { TRACE(("TemplateNodeInclude(%s)\n",data.data())); - ExpressionParser ep(m_templateName,line); + ExpressionParser ep(parser,line); if (data.isEmpty()) { - warn(m_templateName,line,"include tag is missing template file argument"); + parser->warn(m_templateName,line,"include tag is missing template file argument"); } m_includeExpr = ep.parsePrimary(data); } @@ -2283,28 +2306,30 @@ class TemplateNodeInclude : public TemplateNodeCreator } void render(FTextStream &ts, TemplateContext *c) { - dynamic_cast(c)->setLocation(m_templateName,m_line); + TemplateContextImpl* ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); if (m_includeExpr) { QCString includeFile = m_includeExpr->resolve(c).toString(); if (includeFile.isEmpty()) { - warn(m_templateName,m_line,"invalid parameter for include command\n"); + ci->warn(m_templateName,m_line,"invalid parameter for include command\n"); } else { TemplateImpl *t = getTemplate(); if (t) { - Template *it = t->engine()->loadByName(includeFile); + Template *it = t->engine()->loadByName(includeFile,m_line); TemplateImpl *incTemplate = it ? dynamic_cast(it) : 0; if (incTemplate) { incTemplate->render(ts,c); + t->engine()->unload(t); } else { - warn(m_templateName,m_line,"failed to load template '%s' for include",includeFile.data()?includeFile.data():""); + ci->warn(m_templateName,m_line,"failed to load template '%s' for include",includeFile.data()?includeFile.data():""); } } } @@ -2325,30 +2350,30 @@ class TemplateNodeCreate : public TemplateNodeCreator : TemplateNodeCreator(parser,parent,line) { TRACE(("TemplateNodeCreate(%s)\n",data.data())); - ExpressionParser ep(m_templateName,line); + ExpressionParser ep(parser,line); if (data.isEmpty()) { - warn(m_templateName,line,"create tag is missing arguments"); + parser->warn(m_templateName,line,"create tag is missing arguments"); } int i = data.find(" from "); if (i==-1) { if (data.right(3)==" from") { - warn(m_templateName,line,"create is missing template name after 'from' keyword"); + parser->warn(m_templateName,line,"create is missing template name after 'from' keyword"); } else if (data=="from") { - warn(m_templateName,line,"create needs a file name and a template name"); + parser->warn(m_templateName,line,"create needs a file name and a template name"); } else { - warn(m_templateName,line,"create is missing 'from' keyword"); + parser->warn(m_templateName,line,"create is missing 'from' keyword"); } } else { - ExpressionParser ep(m_templateName,line); + ExpressionParser ep(parser,line); m_fileExpr = ep.parsePrimary(data.left(i).stripWhiteSpace()); m_templateExpr = ep.parsePrimary(data.mid(i+6).stripWhiteSpace()); } @@ -2368,18 +2393,18 @@ class TemplateNodeCreate : public TemplateNodeCreator QCString outputFile = m_fileExpr->resolve(c).toString(); if (templateFile.isEmpty()) { - warn(m_templateName,m_line,"empty template name parameter for create command\n"); + ci->warn(m_templateName,m_line,"empty template name parameter for create command\n"); } else if (outputFile.isEmpty()) { - warn(m_templateName,m_line,"empty file name parameter for create command\n"); + ci->warn(m_templateName,m_line,"empty file name parameter for create command\n"); } else { TemplateImpl *t = getTemplate(); if (t) { - Template *ct = t->engine()->loadByName(templateFile); + Template *ct = t->engine()->loadByName(templateFile,m_line); TemplateImpl *createTemplate = ct ? dynamic_cast(ct) : 0; if (createTemplate) { @@ -2392,16 +2417,16 @@ class TemplateNodeCreate : public TemplateNodeCreator { FTextStream ts(&f); createTemplate->render(ts,c); - //delete createTemplate; + t->engine()->unload(t); } else { - warn(m_templateName,m_line,"failed to open output file '%s' for create command",outputFile.data()); + ci->warn(m_templateName,m_line,"failed to open output file '%s' for create command",outputFile.data()); } } else { - warn(m_templateName,m_line,"failed to load template '%s' for include",templateFile.data()); + ci->warn(m_templateName,m_line,"failed to load template '%s' for include",templateFile.data()); } } } @@ -2431,10 +2456,10 @@ class TemplateNodeTree : public TemplateNodeCreator : TemplateNodeCreator(parser,parent,line) { TRACE(("{TemplateNodeTree(%s)\n",data.data())); - ExpressionParser ep(m_templateName,line); + ExpressionParser ep(parser,line); if (data.isEmpty()) { - warn(m_templateName,line,"recursetree tag is missing data argument"); + parser->warn(m_templateName,line,"recursetree tag is missing data argument"); } m_treeExpr = ep.parsePrimary(data); QStrList stopAt; @@ -2508,7 +2533,7 @@ class TemplateNodeTree : public TemplateNodeCreator } else { - warn(m_templateName,m_line,"recursetree's argument should be a list type"); + ci->warn(m_templateName,m_line,"recursetree's argument should be a list type"); } } @@ -2535,7 +2560,7 @@ class TemplateNodeWith : public TemplateNodeCreator { TRACE(("{TemplateNodeWith(%s)\n",data.data())); m_args.setAutoDelete(TRUE); - ExpressionParser expParser(parser->templateName(),line); + ExpressionParser expParser(parser,line); QValueList args = split(data," "); QValueListIterator it = args.begin(); while (it!=args.end()) @@ -2552,7 +2577,7 @@ class TemplateNodeWith : public TemplateNodeCreator } else { - warn(parser->templateName(),line,"invalid argument '%s' for with tag",arg.data()); + parser->warn(parser->templateName(),line,"invalid argument '%s' for with tag",arg.data()); } ++it; } @@ -2568,6 +2593,7 @@ class TemplateNodeWith : public TemplateNodeCreator void render(FTextStream &ts, TemplateContext *c) { TemplateContextImpl *ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); c->push(); QListIterator it(m_args); Mapping *mapping; @@ -2596,7 +2622,7 @@ class TemplateNodeCycle : public TemplateNodeCreator TRACE(("{TemplateNodeCycle(%s)\n",data.data())); m_args.setAutoDelete(TRUE); m_index=0; - ExpressionParser expParser(parser->templateName(),line); + ExpressionParser expParser(parser,line); QValueList args = split(data," "); QValueListIterator it = args.begin(); while (it!=args.end()) @@ -2610,13 +2636,14 @@ class TemplateNodeCycle : public TemplateNodeCreator } if (m_args.count()<2) { - warn(parser->templateName(),line,"expected at least two arguments for cycle command, got %d",m_args.count()); + parser->warn(parser->templateName(),line,"expected at least two arguments for cycle command, got %d",m_args.count()); } TRACE(("}TemplateNodeCycle(%s)\n",data.data())); } void render(FTextStream &ts, TemplateContext *c) { TemplateContextImpl *ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); if (m_indexresolve(c); @@ -2661,7 +2688,7 @@ class TemplateNodeSet : public TemplateNodeCreator { TRACE(("{TemplateNodeSet(%s)\n",data.data())); m_args.setAutoDelete(TRUE); - ExpressionParser expParser(parser->templateName(),line); + ExpressionParser expParser(parser,line); QValueList args = split(data," "); QValueListIterator it = args.begin(); while (it!=args.end()) @@ -2678,7 +2705,7 @@ class TemplateNodeSet : public TemplateNodeCreator } else { - warn(parser->templateName(),line,"invalid argument '%s' for with tag",arg.data()); + parser->warn(parser->templateName(),line,"invalid argument '%s' for with tag",arg.data()); } ++it; } @@ -2687,6 +2714,7 @@ class TemplateNodeSet : public TemplateNodeCreator void render(FTextStream &, TemplateContext *c) { TemplateContextImpl *ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); QListIterator it(m_args); Mapping *mapping; for (it.toFirst();(mapping=it.current());++it) @@ -2718,6 +2746,7 @@ class TemplateNodeSpaceless : public TemplateNodeCreator void render(FTextStream &ts, TemplateContext *c) { TemplateContextImpl *ci = dynamic_cast(c); + ci->setLocation(m_templateName,m_line); bool wasSpaceless = ci->spacelessEnabled(); ci->enableSpaceless(TRUE); m_nodes.render(ts,c); @@ -2741,11 +2770,11 @@ class TemplateNodeMarkers : public TemplateNodeCreator int w = data.find(" with "); if (i==-1 || w==-1 || w in with "); + parser->warn(m_templateName,line,"markers tag as wrong format. Expected: markers in with "); } else { - ExpressionParser expParser(parser->templateName(),line); + ExpressionParser expParser(parser,line); m_var = data.left(i); m_listExpr = expParser.parseVariable(data.mid(i+4,w-i-4)); m_patternExpr = expParser.parseVariable(data.right(data.length()-w-6)); @@ -2796,11 +2825,11 @@ class TemplateNodeMarkers : public TemplateNodeCreator } else if (!ok) { - warn(m_templateName,m_line,"markers pattern string has invalid markers '%s'",str.data()); + ci->warn(m_templateName,m_line,"markers pattern string has invalid markers '%s'",str.data()); } else if (iwarn(m_templateName,m_line,"markers list does not an element for marker position %d",i); } index=newIndex+matchLen; // set index just after marker } @@ -2809,12 +2838,12 @@ class TemplateNodeMarkers : public TemplateNodeCreator } else { - warn(m_templateName,m_line,"markers requires a parameter of string type after 'with'!"); + ci->warn(m_templateName,m_line,"markers requires a parameter of string type after 'with'!"); } } else { - warn(m_templateName,m_line,"markers requires a parameter of list type after 'in'!"); + ci->warn(m_templateName,m_line,"markers requires a parameter of list type after 'in'!"); } } } @@ -2970,19 +2999,20 @@ void TemplateBlockContext::push(TemplateNodeBlock *block) class TemplateLexer { public: - TemplateLexer(const QCString &fileName,const QCString &data); + TemplateLexer(const TemplateEngine *engine,const QCString &fileName,const QCString &data); void tokenize(QList &tokens); private: void addToken(QList &tokens, const char *data,int line,int startPos,int endPos, TemplateToken::Type type); void reset(); + const TemplateEngine *m_engine; QCString m_fileName; QCString m_data; }; -TemplateLexer::TemplateLexer(const QCString &fileName,const QCString &data) : - m_fileName(fileName), m_data(data) +TemplateLexer::TemplateLexer(const TemplateEngine *engine,const QCString &fileName,const QCString &data) : + m_engine(engine), m_fileName(fileName), m_data(data) { } @@ -3049,6 +3079,7 @@ void TemplateLexer::tokenize(QList &tokens) if (c=='\n') { warn(m_fileName,line,"unexpected new line inside {%%...%%} block"); + m_engine->printIncludeContext(m_fileName,line); } else if (c=='%') // %} or something else { @@ -3072,6 +3103,7 @@ void TemplateLexer::tokenize(QList &tokens) if (c=='\n') { warn(m_fileName,line,"unexpected new line inside {%%...%%} block"); + m_engine->printIncludeContext(m_fileName,line); } state=StateTag; } @@ -3080,6 +3112,7 @@ void TemplateLexer::tokenize(QList &tokens) if (c=='\n') { warn(m_fileName,line,"unexpected new line inside {#...#} block"); + m_engine->printIncludeContext(m_fileName,line); } else if (c=='#') // #} or something else { @@ -3101,6 +3134,7 @@ void TemplateLexer::tokenize(QList &tokens) if (c=='\n') { warn(m_fileName,line,"unexpected new line inside {#...#} block"); + m_engine->printIncludeContext(m_fileName,line); } state=StateComment; } @@ -3125,6 +3159,7 @@ void TemplateLexer::tokenize(QList &tokens) if (c=='\n') { warn(m_fileName,line,"unexpected new line inside {{...}} block"); + m_engine->printIncludeContext(m_fileName,line); } else if (c=='}') // }} or something else { @@ -3148,6 +3183,7 @@ void TemplateLexer::tokenize(QList &tokens) if (c=='\n') { warn(m_fileName,line,"unexpected new line inside {{...}} block"); + m_engine->printIncludeContext(m_fileName,line); } state=StateVariable; } @@ -3192,9 +3228,10 @@ void TemplateLexer::addToken(QList &tokens, //---------------------------------------------------------- -TemplateParser::TemplateParser(const QCString &templateName, +TemplateParser::TemplateParser(const TemplateEngine *engine, + const QCString &templateName, QList &tokens) : - m_templateName(templateName), m_tokens(tokens) + m_engine(engine), m_templateName(templateName), m_tokens(tokens) { } @@ -3214,10 +3251,10 @@ void TemplateParser::parse( case TemplateToken::Text: nodes.append(new TemplateNodeText(this,parent,tok->line,tok->data)); break; - case TemplateToken::Variable: + case TemplateToken::Variable: // {{ var }} nodes.append(new TemplateNodeVariable(this,parent,tok->line,tok->data)); break; - case TemplateToken::Block: + case TemplateToken::Block: // {% tag %} { QCString command = tok->data; int sep = command.find(' '); @@ -3301,6 +3338,15 @@ void TemplateParser::prependToken(const TemplateToken *token) m_tokens.prepend(token); } +void TemplateParser::warn(const char *fileName,int line,const char *fmt,...) const +{ + va_list args; + va_start(args,fmt); + ::warn(fileName,line,fmt,args); + va_end(args); + m_engine->printIncludeContext(fileName,line); +} + //---------------------------------------------------------- @@ -3311,11 +3357,11 @@ TemplateImpl::TemplateImpl(TemplateEngine *engine,const QCString &name,const QCS { m_name = name; m_engine = engine; - TemplateLexer lexer(name,data); + TemplateLexer lexer(engine,name,data); QList tokens; tokens.setAutoDelete(TRUE); lexer.tokenize(tokens); - TemplateParser parser(name,tokens); + TemplateParser parser(engine,name,tokens); parser.parse(this,1,QStrList(),m_nodes); } @@ -3348,11 +3394,35 @@ void TemplateImpl::render(FTextStream &ts, TemplateContext *c) /** @brief Private data of the template engine */ class TemplateEngine::Private { + class IncludeEntry + { + public: + enum Type { Template, Block }; + IncludeEntry(Type type,const QCString &fileName,const QCString &blockName,int line) + : m_type(type), m_fileName(fileName), m_blockName(blockName), m_line(line) {} + Type type() const { return m_type; } + QCString fileName() const { return m_fileName; } + QCString blockName() const { return m_blockName; } + int line() const { return m_line; } + + private: + Type m_type; + QCString m_fileName; + QCString m_blockName; + int m_line; + }; public: - Private(TemplateEngine *engine) : m_templateCache(17), m_engine(engine) - { m_templateCache.setAutoDelete(TRUE); } - Template *loadByName(const QCString &fileName) const + Private(TemplateEngine *engine) : m_templateCache(17) /*, m_indent(0)*/, m_engine(engine) { + m_templateCache.setAutoDelete(TRUE); + m_includeStack.setAutoDelete(TRUE); + } + Template *loadByName(const QCString &fileName,int line) + { + //for (int i=0;i li(m_includeStack); + li.toLast(); + IncludeEntry *ie=li.current(); + while ((ie=li.current())) + { + --li; + IncludeEntry *next=li.current(); + if (ie->type()==IncludeEntry::Template) + { + if (next) + { + warn(fileName,line," inside template '%s' included from template '%s' at line %d",ie->fileName().data(),next->fileName().data(),ie->line()); + } + } + else // ie->type()==IncludeEntry::Block + { + warn(fileName,line," included by block '%s' inside template '%s' at line %d",ie->blockName().data(), + ie->fileName().data(),ie->line()); + } + } + } private: - mutable QDict