Added reference counting for all context objects

src/context.h

@@ -4,6 +4,7 @@
 #include "types.h"
 #include "template.h"
 #include <qlist.h>
+#include <stdio.h>
 
 class Definition;
 class ClassDef;
@@ -38,102 +39,190 @@ class MemberGroupList;
 
 //----------------------------------------------------
 
-class ConfigContext : public TemplateStructIntf
+#define DEBUG_REF 0
+
+/** @brief Helper class to support reference counting */
+#if DEBUG_REF
+class RefCountedContext
 {
   public:
-    ConfigContext();
-   ~ConfigContext();
+    RefCountedContext(const char *className) : m_refCount(0)
+    {
+      m_className=className;
+      m_insideRelease = FALSE;
+    }
+    virtual ~RefCountedContext()
+    {
+      if (!m_insideRelease) abort();
+    }
+    int addRef()
+    {
+      ++s_totalCount;
+      printf("%p:%s::addRef()=%d\n",this,m_className.data(),m_refCount);
+      return ++m_refCount;
+    }
+    int release()
+    {
+      --s_totalCount;
+      printf("%p:%s::release()=%d\n",this,m_className.data(),m_refCount-1);
+      int count = --m_refCount;
+      if (count<=0)
+      {
+        m_insideRelease=TRUE;
+        delete this;
+      }
+      return count;
+    }
+  private:
+    int m_refCount;
+    QCString m_className;
+    bool m_insideRelease;
+  public:
+    static int s_totalCount;
+};
+
+#else // release version
+
+class RefCountedContext
+{
+  public:
+    RefCountedContext(const char *) : m_refCount(0) {}
+    virtual ~RefCountedContext() {}
+    int addRef() { return ++m_refCount; }
+    int release()
+    {
+      int count = --m_refCount;
+      if (count<=0)
+      {
+        delete this;
+      }
+      return count;
+    }
+  private:
+    int m_refCount;
+};
+#endif
+
+
+//----------------------------------------------------
+
+class ConfigContext : public RefCountedContext, public TemplateStructIntf
+{
+  public:
+    static ConfigContext *alloc() { return new ConfigContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ConfigContext();
+   ~ConfigContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class DoxygenContext : public TemplateStructIntf
+class DoxygenContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    DoxygenContext();
-   ~DoxygenContext();
+    static DoxygenContext *alloc() { return new DoxygenContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    DoxygenContext();
+   ~DoxygenContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class TranslateContext : public TemplateStructIntf
+class TranslateContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    TranslateContext();
-   ~TranslateContext();
+    static TranslateContext *alloc() { return new TranslateContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    TranslateContext();
+   ~TranslateContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class UsedFilesContext : public TemplateListIntf
+class UsedFilesContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    UsedFilesContext(ClassDef *cd);
-   ~UsedFilesContext();
+    static UsedFilesContext *alloc(ClassDef *cd) { return new UsedFilesContext(cd); }
 
     // TemplateListIntf
     virtual int count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void addFile(FileDef *fd);
 
   private:
+    UsedFilesContext(ClassDef *cd);
+   ~UsedFilesContext();
+
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class IncludeInfoContext : public TemplateStructIntf
+class IncludeInfoContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    IncludeInfoContext(const IncludeInfo *,SrcLangExt lang);
-   ~IncludeInfoContext();
+    static IncludeInfoContext *alloc(const IncludeInfo *info,SrcLangExt lang)
+    { return new IncludeInfoContext(info,lang); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    IncludeInfoContext(const IncludeInfo *,SrcLangExt lang);
+   ~IncludeInfoContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class IncludeInfoListContext : public TemplateListIntf
+class IncludeInfoListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    IncludeInfoListContext(const QList<IncludeInfo> &list,SrcLangExt lang);
-   ~IncludeInfoListContext();
+    static IncludeInfoListContext *alloc(const QList<IncludeInfo> &list,SrcLangExt lang)
+    { return new IncludeInfoListContext(list,lang); }
 
     // TemplateListIntf
     virtual int count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    IncludeInfoListContext(const QList<IncludeInfo> &list,SrcLangExt lang);
+   ~IncludeInfoListContext();
     class Private;
     Private *p;
 };
@@ -141,63 +230,75 @@ class IncludeInfoListContext : public TemplateListIntf
 
 //----------------------------------------------------
 
-class ClassContext : public TemplateStructIntf
+class ClassContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ClassContext(ClassDef *);
-   ~ClassContext();
+    static ClassContext *alloc(ClassDef *cd) { return new ClassContext(cd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ClassContext(ClassDef *);
+   ~ClassContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NamespaceContext : public TemplateStructIntf
+class NamespaceContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    NamespaceContext(NamespaceDef *);
-   ~NamespaceContext();
+    static NamespaceContext *alloc(NamespaceDef *nd) { return new NamespaceContext(nd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    NamespaceContext(NamespaceDef *);
+   ~NamespaceContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class FileContext : public TemplateStructIntf
+class FileContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    FileContext(FileDef *);
-   ~FileContext();
+    static FileContext *alloc(FileDef *fd) { return new FileContext(fd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    FileContext(FileDef *);
+   ~FileContext();
     class Private;
     Private *p;
 };
 //----------------------------------------------------
 
-class DirContext : public TemplateStructIntf
+class DirContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    DirContext(DirDef *);
-   ~DirContext();
+    static DirContext *alloc(DirDef *dd) { return new DirContext(dd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    DirContext(DirDef *);
+   ~DirContext();
     class Private;
     Private *p;
 };
@@ -205,32 +306,38 @@ class DirContext : public TemplateStructIntf
 
 //----------------------------------------------------
 
-class PageContext : public TemplateStructIntf
+class PageContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    PageContext(PageDef *);
-   ~PageContext();
+    static PageContext *alloc(PageDef *pd) { return new PageContext(pd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    PageContext(PageDef *);
+   ~PageContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class MemberContext : public TemplateStructIntf
+class MemberContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    MemberContext(MemberDef *);
-   ~MemberContext();
+    static MemberContext *alloc(MemberDef *md) { return new MemberContext(md); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    MemberContext(MemberDef *);
+   ~MemberContext();
     class Private;
     Private *p;
 };
@@ -238,159 +345,190 @@ class MemberContext : public TemplateStructIntf
 
 //----------------------------------------------------
 
-class ModuleContext : public TemplateStructIntf
+class ModuleContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ModuleContext(GroupDef *);
-   ~ModuleContext();
+    static ModuleContext *alloc(GroupDef *gd) { return new ModuleContext(gd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ModuleContext(GroupDef *);
+   ~ModuleContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NestedClassListContext : public TemplateListIntf
+class NestedClassListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    NestedClassListContext();
-   ~NestedClassListContext();
+    static NestedClassListContext *alloc() { return new NestedClassListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void append(ClassDef *cd);
 
   private:
+    NestedClassListContext();
+   ~NestedClassListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NestedNamespaceListContext : public TemplateListIntf
+class NestedNamespaceListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    NestedNamespaceListContext();
-   ~NestedNamespaceListContext();
+    static NestedNamespaceListContext *alloc() { return new NestedNamespaceListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void append(NamespaceDef *cd);
 
   private:
+    NestedNamespaceListContext();
+   ~NestedNamespaceListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ClassListContext : public TemplateListIntf
+class ClassListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    ClassListContext();
-   ~ClassListContext();
+    static ClassListContext *alloc() { return new ClassListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ClassListContext();
+   ~ClassListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ClassInheritanceNodeContext : public TemplateStructIntf
+class ClassInheritanceNodeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ClassInheritanceNodeContext(ClassDef *);
-   ~ClassInheritanceNodeContext();
+    static ClassInheritanceNodeContext *alloc(ClassDef *cd)
+    { return new ClassInheritanceNodeContext(cd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void addChildren(const BaseClassList *bcl,bool hideSuper);
+
   private:
+    ClassInheritanceNodeContext(ClassDef *);
+   ~ClassInheritanceNodeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ClassInheritanceContext : public TemplateListIntf
+class ClassInheritanceContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    ClassInheritanceContext();
-   ~ClassInheritanceContext();
+    static ClassInheritanceContext *alloc() { return new ClassInheritanceContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ClassInheritanceContext();
+   ~ClassInheritanceContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ClassHierarchyContext : public TemplateStructIntf
+class ClassHierarchyContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ClassHierarchyContext();
-   ~ClassHierarchyContext();
+    static ClassHierarchyContext *alloc() { return new ClassHierarchyContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ClassHierarchyContext();
+   ~ClassHierarchyContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NestingNodeContext : public TemplateStructIntf
+class NestingNodeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    NestingNodeContext(const NestingNodeContext *parent,
-                       Definition *,int index,int level,bool addClasses);
-   ~NestingNodeContext();
+    static NestingNodeContext *alloc(const NestingNodeContext *parent,Definition *def,
+                                     int index,int level,bool addClasses)
+    { return new NestingNodeContext(parent,def,index,level,addClasses); }
+
     QCString id() const;
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    NestingNodeContext(const NestingNodeContext *parent,
+                       Definition *,int index,int level,bool addClasses);
+   ~NestingNodeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NestingContext : public TemplateListIntf
+class NestingContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    NestingContext(const NestingNodeContext *parent,int level);
-   ~NestingContext();
+    static NestingContext *alloc(const NestingNodeContext *parent,int level)
+    { return new NestingContext(parent,level); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void addNamespaces(const NamespaceSDict &nsDict,bool rootOnly,bool addClasses);
     void addClasses(const ClassSDict &clDict,bool rootOnly);
@@ -398,302 +536,310 @@ class NestingContext : public TemplateListIntf
     void addDirs(const DirList &);
     void addFiles(const FileNameList &);
     void addFiles(const FileList &);
+
   private:
+    NestingContext(const NestingNodeContext *parent,int level);
+   ~NestingContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ClassTreeContext : public TemplateStructIntf
+class ClassTreeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ClassTreeContext();
-   ~ClassTreeContext();
+    static ClassTreeContext *alloc() { return new ClassTreeContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ClassTreeContext();
+   ~ClassTreeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NamespaceListContext : public TemplateListIntf
+class NamespaceListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    NamespaceListContext();
-   ~NamespaceListContext();
+    static NamespaceListContext *alloc() { return new NamespaceListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    NamespaceListContext();
+   ~NamespaceListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NamespaceTreeContext : public TemplateStructIntf
-{
-  public:
-    NamespaceTreeContext();
-   ~NamespaceTreeContext();
-
-    // TemplateStructIntf methods
-    virtual TemplateVariant get(const char *name) const;
-
-  private:
-    class Private;
-    Private *p;
-};
-
-//----------------------------------------------------
-#if 0
-
-class DirFileNodeContext : public TemplateStructIntf
+class NamespaceTreeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    DirFileNodeContext(const DirFileNodeContext *parent,
-                       Definition *,int index,int level);
-   ~DirFileNodeContext();
-    QCString id() const;
+    static NamespaceTreeContext *alloc() { return new NamespaceTreeContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    NamespaceTreeContext();
+   ~NamespaceTreeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class DirFileContext : public TemplateListIntf
+class DirListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    DirFileContext(const DirFileNodeContext *parent,int level);
-   ~DirFileContext();
+    static DirListContext *alloc() { return new DirListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
-    void addDirs(const DirSDict &);
-    void addDirs(const DirList &);
-    void addFiles(const FileNameList &);
-    void addFiles(const FileList &);
   private:
-    class Private;
-    Private *p;
-};
-#endif
-
-//----------------------------------------------------
-
-class DirListContext : public TemplateListIntf
-{
-  public:
     DirListContext();
    ~DirListContext();
-
-    // TemplateListIntf
-    virtual int  count() const;
-    virtual TemplateVariant at(int index) const;
-    virtual TemplateListIntf::ConstIterator *createIterator() const;
-
-  private:
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class FileListContext : public TemplateListIntf
+class FileListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    FileListContext();
-   ~FileListContext();
+    static FileListContext *alloc() { return new FileListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    FileListContext();
+   ~FileListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class FileTreeContext : public TemplateStructIntf
+class FileTreeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    FileTreeContext();
-   ~FileTreeContext();
+    static FileTreeContext *alloc() { return new FileTreeContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    FileTreeContext();
+   ~FileTreeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class PageNodeContext : public TemplateStructIntf
+class PageNodeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    PageNodeContext(PageDef *);
-   ~PageNodeContext();
+    static PageNodeContext *alloc(PageDef *pd) { return new PageNodeContext(pd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    PageNodeContext(PageDef *);
+   ~PageNodeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class PageNodeListContext : public TemplateListIntf
+class PageNodeListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    PageNodeListContext();
-   ~PageNodeListContext();
+    static PageNodeListContext *alloc() { return new PageNodeListContext; }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void addPages(const PageSDict &,bool rootOnly);
+
   private:
+    PageNodeListContext();
+   ~PageNodeListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class PageListContext : public TemplateStructIntf
+class PageListContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    PageListContext();
-   ~PageListContext();
+    static PageListContext *alloc() { return new PageListContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    PageListContext();
+   ~PageListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class PageTreeContext : public TemplateStructIntf
+class PageTreeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    PageTreeContext();
-   ~PageTreeContext();
+    static PageTreeContext *alloc() { return new PageTreeContext; }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    PageTreeContext();
+   ~PageTreeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ModuleNodeContext : public TemplateStructIntf
+class ModuleNodeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ModuleNodeContext(GroupDef *);
-   ~ModuleNodeContext();
+    static ModuleNodeContext *alloc(GroupDef *gd) { return new ModuleNodeContext(gd); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ModuleNodeContext(GroupDef *);
+   ~ModuleNodeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ModuleListContext : public TemplateListIntf
+class ModuleListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    ModuleListContext();
-   ~ModuleListContext();
+    static ModuleListContext *alloc() { return new ModuleListContext(); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
     void addModules(const GroupSDict &);
     void addModules(const GroupList &);
+
   private:
+    ModuleListContext();
+   ~ModuleListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ModuleTreeContext : public TemplateStructIntf
+class ModuleTreeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ModuleTreeContext();
-   ~ModuleTreeContext();
+    static ModuleTreeContext *alloc() { return new ModuleTreeContext(); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ModuleTreeContext();
+   ~ModuleTreeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ExampleListContext : public TemplateStructIntf
+class ExampleListContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ExampleListContext();
-   ~ExampleListContext();
+    static ExampleListContext *alloc() { return new ExampleListContext(); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ExampleListContext();
+   ~ExampleListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class NavPathElemContext : public TemplateStructIntf
+class NavPathElemContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    NavPathElemContext(Definition *def);
-   ~NavPathElemContext();
+    static NavPathElemContext *alloc(Definition *def) { return new NavPathElemContext(def); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    NavPathElemContext(Definition *def);
+   ~NavPathElemContext();
     class Private;
     Private *p;
 };
@@ -701,90 +847,118 @@ class NavPathElemContext : public TemplateStructIntf
 
 //----------------------------------------------------
 
-class InheritanceNodeContext : public TemplateStructIntf
+class InheritanceNodeContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    InheritanceNodeContext(ClassDef *cd,const QCString &name);
-   ~InheritanceNodeContext();
+    static InheritanceNodeContext *alloc(ClassDef *cd,const QCString &name)
+    { return new InheritanceNodeContext(cd,name); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    InheritanceNodeContext(ClassDef *cd,const QCString &name);
+   ~InheritanceNodeContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class InheritanceListContext : public TemplateListIntf
+class InheritanceListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    InheritanceListContext(const BaseClassList *list,bool baseClasses);
-   ~InheritanceListContext();
+    static InheritanceListContext *alloc(const BaseClassList *list,bool baseClasses)
+    { return new InheritanceListContext(list,baseClasses); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    InheritanceListContext(const BaseClassList *list,bool baseClasses);
+   ~InheritanceListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class MemberListContext : public TemplateListIntf
+class MemberListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    MemberListContext();
-    MemberListContext(const MemberList *ml);
-    MemberListContext(MemberSDict *ml,bool doSort);
-   ~MemberListContext();
+    static MemberListContext *alloc()
+    { return new MemberListContext; }
+    static MemberListContext *alloc(const MemberList *ml)
+    { return new MemberListContext(ml); }
+    static MemberListContext *alloc(MemberSDict *ml,bool doSort)
+    { return new MemberListContext(ml,doSort); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    MemberListContext();
+    MemberListContext(const MemberList *ml);
+    MemberListContext(MemberSDict *ml,bool doSort);
+   ~MemberListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class MemberGroupInfoContext : public TemplateStructIntf
+class MemberGroupInfoContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    MemberGroupInfoContext(Definition *def,const QCString &relPath,const MemberGroup *mg);
-   ~MemberGroupInfoContext();
+    static MemberGroupInfoContext *alloc(Definition *def,const QCString &relPath,const MemberGroup *mg)
+    { return new MemberGroupInfoContext(def,relPath,mg); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    MemberGroupInfoContext(Definition *def,const QCString &relPath,const MemberGroup *mg);
+   ~MemberGroupInfoContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class MemberGroupListContext : public TemplateListIntf
+class MemberGroupListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    MemberGroupListContext();
-    MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list);
-    MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *mgDict,bool subGrouping);
-   ~MemberGroupListContext();
+    static MemberGroupListContext *alloc()
+    { return new MemberGroupListContext; }
+    static MemberGroupListContext *alloc(Definition *def,const QCString &relPath,const MemberGroupList *list)
+    { return new MemberGroupListContext(def,relPath,list); }
+    static MemberGroupListContext *alloc(Definition *def,const QCString &relPath,const MemberGroupSDict *dict,bool subGrouping)
+    { return new MemberGroupListContext(def,relPath,dict,subGrouping); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    MemberGroupListContext();
+    MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list);
+    MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *mgDict,bool subGrouping);
+   ~MemberGroupListContext();
     class Private;
     Private *p;
 };
@@ -792,123 +966,154 @@ class MemberGroupListContext : public TemplateListIntf
 
 //----------------------------------------------------
 
-class MemberListInfoContext : public TemplateStructIntf
+class MemberListInfoContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    MemberListInfoContext(Definition *def,const QCString &relPath,
+    static MemberListInfoContext *alloc(Definition *def,const QCString &relPath,
                           const MemberList *ml,const QCString &title,
-                          const QCString &subtitle=QCString());
-   ~MemberListInfoContext();
+                          const QCString &subtitle=QCString())
+    { return new MemberListInfoContext(def,relPath,ml,title,subtitle); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    MemberListInfoContext(Definition *def,const QCString &relPath,
+                          const MemberList *ml,const QCString &title,
+                          const QCString &subtitle=QCString());
+   ~MemberListInfoContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class MemberInfoContext : public TemplateStructIntf
+class MemberInfoContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    MemberInfoContext(const MemberInfo *mi);
-   ~MemberInfoContext();
+    static MemberInfoContext *alloc(const MemberInfo *mi) { return new MemberInfoContext(mi); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    MemberInfoContext(const MemberInfo *mi);
+   ~MemberInfoContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class InheritedMemberInfoContext : public TemplateStructIntf
+class InheritedMemberInfoContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    InheritedMemberInfoContext(ClassDef *cd,MemberList *ml,const QCString &title);
-   ~InheritedMemberInfoContext();
+    static InheritedMemberInfoContext *alloc(ClassDef *cd,MemberList *ml,const QCString &title)
+    { return new InheritedMemberInfoContext(cd,ml,title); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    InheritedMemberInfoContext(ClassDef *cd,MemberList *ml,const QCString &title);
+   ~InheritedMemberInfoContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class InheritedMemberInfoListContext : public TemplateListIntf
+class InheritedMemberInfoListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    InheritedMemberInfoListContext();
+    static InheritedMemberInfoListContext *alloc() { return new InheritedMemberInfoListContext; }
     void addMemberList(ClassDef *cd,MemberListType lt,const QCString &title,bool additionalList=TRUE);
-   ~InheritedMemberInfoListContext();
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    InheritedMemberInfoListContext();
+   ~InheritedMemberInfoListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class AllMembersListContext : public TemplateListIntf
+class AllMembersListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    AllMembersListContext();
-    AllMembersListContext(const MemberNameInfoSDict *ml);
-   ~AllMembersListContext();
+    static AllMembersListContext *alloc()
+    { return new AllMembersListContext; }
+    static AllMembersListContext *alloc(const MemberNameInfoSDict *ml)
+    { return new AllMembersListContext(ml); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    AllMembersListContext();
+    AllMembersListContext(const MemberNameInfoSDict *ml);
+   ~AllMembersListContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ArgumentContext : public TemplateStructIntf
+class ArgumentContext : public RefCountedContext, public TemplateStructIntf
 {
   public:
-    ArgumentContext(const Argument *arg,Definition *def,const QCString &relPath);
-   ~ArgumentContext();
+    static ArgumentContext *alloc(const Argument *arg,Definition *def,const QCString &relPath)
+    { return new ArgumentContext(arg,def,relPath); }
 
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ArgumentContext(const Argument *arg,Definition *def,const QCString &relPath);
+   ~ArgumentContext();
     class Private;
     Private *p;
 };
 
 //----------------------------------------------------
 
-class ArgumentListContext : public TemplateListIntf
+class ArgumentListContext : public RefCountedContext, public TemplateListIntf
 {
   public:
-    ArgumentListContext();
-    ArgumentListContext(const ArgumentList *al,Definition *def,const QCString &relPath);
-   ~ArgumentListContext();
+    static ArgumentListContext *alloc() { return new ArgumentListContext; }
+    static ArgumentListContext *alloc(const ArgumentList *al,Definition *def,const QCString &relPath)
+    { return new ArgumentListContext(al,def,relPath); }
 
     // TemplateListIntf
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef()  { return RefCountedContext::addRef(); }
+    virtual int release() { return RefCountedContext::release(); }
 
   private:
+    ArgumentListContext();
+    ArgumentListContext(const ArgumentList *al,Definition *def,const QCString &relPath);
+   ~ArgumentListContext();
     class Private;
     Private *p;
 };

src/ftextstream.cpp

@@ -165,6 +165,7 @@ FTextStream::FTextStream( FILE *fh )
 {
   m_dev = new QFile;
   ((QFile *)m_dev)->open( IO_WriteOnly, fh);
+  m_owndev = TRUE;
 }
 
 FTextStream::~FTextStream()

src/template.cpp

@@ -103,8 +103,8 @@ class TemplateVariant::Private
     int                 intVal;
     QCString            strVal;
     bool                boolVal;
-    const TemplateStructIntf *strukt;
-    const TemplateListIntf   *list;
+    TemplateStructIntf *strukt;
+    TemplateListIntf   *list;
     Delegate            delegate;
     bool                raw;
 };
@@ -145,17 +145,20 @@ TemplateVariant::TemplateVariant(const QCString &s,bool raw)
   p->raw = raw;
 }
 
-TemplateVariant::TemplateVariant(const TemplateStructIntf *s)
+TemplateVariant::TemplateVariant(TemplateStructIntf *s)
 {
   p = new Private;
   p->type = Struct;
-  p->strukt = s; }
+  p->strukt = s;
+  p->strukt->addRef();
+}
 
-TemplateVariant::TemplateVariant(const TemplateListIntf *l)
+TemplateVariant::TemplateVariant(TemplateListIntf *l)
 {
   p = new Private;
   p->type = List;
   p->list = l;
+  p->list->addRef();
 }
 
 TemplateVariant::TemplateVariant(const TemplateVariant::Delegate &delegate)
@@ -167,6 +170,8 @@ TemplateVariant::TemplateVariant(const TemplateVariant::Delegate &delegate)
 
 TemplateVariant::~TemplateVariant()
 {
+  if (p->type==Struct) p->strukt->release();
+  else if (p->type==List) p->list->release();
   delete p;
 }
 
@@ -181,14 +186,20 @@ TemplateVariant::TemplateVariant(const TemplateVariant &v)
     case Bool:     p->boolVal = v.p->boolVal; break;
     case Integer:  p->intVal  = v.p->intVal;  break;
     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 Struct:   p->strukt  = v.p->strukt;  p->strukt->addRef(); break;
+    case List:     p->list    = v.p->list;    p->list->addRef();   break;
     case Function: p->delegate= v.p->delegate;break;
   }
 }
 
 TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
 {
+  // assignment can change the type of the variable, so we have to be
+  // careful with reference counted content.
+  TemplateStructIntf *tmpStruct = p->type==Struct ? p->strukt : 0;
+  TemplateListIntf   *tmpList   = p->type==List   ? p->list   : 0;
+  Type tmpType = p->type;
+
   p->type    = v.p->type;
   p->raw     = v.p->raw;
   switch (p->type)
@@ -197,10 +208,14 @@ TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
     case Bool:     p->boolVal = v.p->boolVal; break;
     case Integer:  p->intVal  = v.p->intVal;  break;
     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 Struct:   p->strukt  = v.p->strukt;  p->strukt->addRef(); break;
+    case List:     p->list    = v.p->list;    p->list->addRef();   break;
     case Function: p->delegate= v.p->delegate;break;
   }
+
+  // release overwritten reference counted values
+  if      (tmpType==Struct && tmpStruct) tmpStruct->release();
+  else if (tmpType==List   && tmpList  ) tmpList->release();
   return *this;
 }
 
@@ -353,9 +368,10 @@ bool TemplateVariant::raw() const
 class TemplateStruct::Private
 {
   public:
-    Private() : fields(17)
+    Private() : fields(17), refCount(0)
     { fields.setAutoDelete(TRUE); }
     QDict<TemplateVariant> fields;
+    int refCount;
 };
 
 TemplateStruct::TemplateStruct()
@@ -368,6 +384,21 @@ TemplateStruct::~TemplateStruct()
   delete p;
 }
 
+int TemplateStruct::addRef()
+{
+  return ++p->refCount;
+}
+
+int TemplateStruct::release()
+{
+  int count = --p->refCount;
+  if (count<=0)
+  {
+    delete this;
+  }
+  return count;
+}
+
 void TemplateStruct::set(const char *name,const TemplateVariant &v)
 {
   TemplateVariant *pv = p->fields.find(name);
@@ -387,6 +418,11 @@ TemplateVariant TemplateStruct::get(const char *name) const
   return v ? *v : TemplateVariant();
 }
 
+TemplateStruct *TemplateStruct::alloc()
+{
+  return new TemplateStruct;
+}
+
 //- Template list implementation ----------------------------------------------
 
 
@@ -394,9 +430,10 @@ TemplateVariant TemplateStruct::get(const char *name) const
 class TemplateList::Private
 {
   public:
-    Private() : index(-1) {}
+    Private() : index(-1), refCount(0) {}
     QValueList<TemplateVariant> elems;
     int index;
+    int refCount;
 };
 
 
@@ -410,6 +447,21 @@ TemplateList::~TemplateList()
   delete p;
 }
 
+int TemplateList::addRef()
+{
+  return ++p->refCount;
+}
+
+int TemplateList::release()
+{
+  int count = --p->refCount;
+  if (count<=0)
+  {
+    delete this;
+  }
+  return count;
+}
+
 int TemplateList::count() const
 {
   return p->elems.count();
@@ -492,6 +544,11 @@ TemplateVariant TemplateList::at(int index) const
   }
 }
 
+TemplateList *TemplateList::alloc()
+{
+  return new TemplateList;
+}
+
 //- Operator types ------------------------------------------------------------
 
 /** @brief Class representing operators that can appear in template expressions */
@@ -2156,14 +2213,14 @@ class TemplateNodeRepeat : public TemplateNodeCreator<TemplateNodeRepeat>
         int i, n = v.toInt();
         for (i=0;i<n;i++)
         {
-          TemplateStruct s;
-          s.set("counter0",    (int)i);
-          s.set("counter",     (int)(i+1));
-          s.set("revcounter",  (int)(n-i));
-          s.set("revcounter0", (int)(n-i-1));
-          s.set("first",i==0);
-          s.set("last", i==n-1);
-          c->set("repeatloop",&s);
+          TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
+          s->set("counter0",    (int)i);
+          s->set("counter",     (int)(i+1));
+          s->set("revcounter",  (int)(n-i));
+          s->set("revcounter0", (int)(n-i-1));
+          s->set("first",i==0);
+          s->set("last", i==n-1);
+          c->set("repeatloop",s.get());
           // render all items for this iteration of the loop
           m_repeatNodes.render(ts,c);
         }
@@ -2285,15 +2342,15 @@ class TemplateNodeRange : public TemplateNodeCreator<TemplateNodeRange>
             while (!done)
             {
               // set the forloop meta-data variable
-              TemplateStruct s;
-              s.set("counter0",    (int)index);
-              s.set("counter",     (int)(index+1));
-              s.set("revcounter",  (int)(l-index));
-              s.set("revcounter0", (int)(l-index-1));
-              s.set("first",index==0);
-              s.set("last", (int)index==l-1);
-              s.set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
-              c->set("forloop",&s);
+              TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
+              s->set("counter0",    (int)index);
+              s->set("counter",     (int)(index+1));
+              s->set("revcounter",  (int)(l-index));
+              s->set("revcounter0", (int)(l-index-1));
+              s->set("first",index==0);
+              s->set("last", (int)index==l-1);
+              s->set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
+              c->set("forloop",s.get());
 
               // set the iterator variable
               c->set(m_var,i);
@@ -2447,15 +2504,15 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
               (it->current(v));
               m_reversed ? it->toPrev() : it->toNext())
           {
-            TemplateStruct s;
-            s.set("counter0",    (int)index);
-            s.set("counter",     (int)(index+1));
-            s.set("revcounter",  (int)(listSize-index));
-            s.set("revcounter0", (int)(listSize-index-1));
-            s.set("first",index==0);
-            s.set("last", index==listSize-1);
-            s.set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
-            c->set("forloop",&s);
+            TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
+            s->set("counter0",    (int)index);
+            s->set("counter",     (int)(index+1));
+            s->set("revcounter",  (int)(listSize-index));
+            s->set("revcounter0", (int)(listSize-index-1));
+            s->set("first",index==0);
+            s->set("last", index==listSize-1);
+            s->set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
+            c->set("forloop",s.get());
 
             // add variables for this loop to the context
             //obj->addVariableToContext(index,m_vars,c);
@@ -2582,9 +2639,9 @@ class TemplateNodeBlock : public TemplateNodeCreator<TemplateNodeBlock>
             m_nodes.render(ss,c); // render parent of nb to string
           }
           // add 'block.super' variable to allow access to parent block content
-          TemplateStruct superBlock;
-          superBlock.set("super",TemplateVariant(super.data(),TRUE));
-          ci->set("block",&superBlock);
+          TemplateAutoRef<TemplateStruct> superBlock(TemplateStruct::alloc());
+          superBlock->set("super",TemplateVariant(super.data(),TRUE));
+          ci->set("block",superBlock.get());
           // render the overruled block contents
           t->engine()->enterBlock(nb->m_templateName,nb->m_blockName,nb->m_line);
           nb->m_nodes.render(ts,c);
@@ -3235,9 +3292,9 @@ class TemplateNodeMarkers : public TemplateNodeCreator<TemplateNodeMarkers>
               for (it->toFirst(); (it->current(var)) && i<entryIndex; it->toNext(),i++) {}
               if (ok && i==entryIndex) // found element
               {
-                TemplateStruct s;
-                s.set("id",(int)i);
-                c->set("markers",&s);
+                TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
+                s->set("id",(int)i);
+                c->set("markers",s.get());
                 c->set(m_var,var); // define local variable to hold element of list type
                 bool wasSpaceless = ci->spacelessEnabled();
                 ci->enableSpaceless(TRUE);

src/template.h

@@ -145,16 +145,14 @@ class TemplateVariant
     TemplateVariant(const QCString &s,bool raw=FALSE);
 
     /** Constructs a new variant with a struct value \a s.
-     *  @note. Only a pointer to the struct is stored. The caller
-     *  is responsible to manage the memory for the struct object.
+     *  @note. The variant will hold a reference to the object.
      */
-    TemplateVariant(const TemplateStructIntf *s);
+    TemplateVariant(TemplateStructIntf *s);
 
     /** Constructs a new variant with a list value \a l.
-     *  @note. Only a pointer to the struct is stored. The caller
-     *  is responsible to manage the memory for the list object.
+     *  @note. The variant will hold a reference to the object.
      */
-    TemplateVariant(const TemplateListIntf *l);
+    TemplateVariant(TemplateListIntf *l);
 
     /** Constructs a new variant which represents a method call
      *  @param[in] delegate Delegate object to invoke when
@@ -223,6 +221,27 @@ class TemplateVariant
 
 //------------------------------------------------------------------------
 
+template<class T> class TemplateAutoRef
+{
+  public:
+    TemplateAutoRef(T *obj) : m_obj(obj)
+    {
+      m_obj->addRef();
+    }
+   ~TemplateAutoRef()
+    {
+      m_obj->release();
+    }
+    T &operator*() const { return *m_obj; }
+    T *operator->() const { return m_obj; }
+    T *get() const { return m_obj; }
+
+  private:
+   T *m_obj;
+};
+
+//------------------------------------------------------------------------
+
 /** @brief Abstract read-only interface for a context value of type list.
  *  @note The values of the list are TemplateVariants.
  */
@@ -264,26 +283,37 @@ class TemplateListIntf
      *  @note the user should call delete on the returned pointer.
      */
     virtual TemplateListIntf::ConstIterator *createIterator() const = 0;
+
+    /** Increase object's reference count */
+    virtual int addRef() = 0;
+
+    /** Decreases object's referenc count, destroy object if 0 */
+    virtual int release() = 0;
 };
 
 /** @brief Default implementation of a context value of type list. */
 class TemplateList : public TemplateListIntf
 {
   public:
-    /** Creates a list */
-    TemplateList();
-    /** Destroys the list */
-   ~TemplateList();
-
     // TemplateListIntf methods
     virtual int  count() const;
     virtual TemplateVariant at(int index) const;
     virtual TemplateListIntf::ConstIterator *createIterator() const;
+    virtual int addRef();
+    virtual int release();
+
+    /** Creates an instance with ref count set to 0 */
+    static TemplateList *alloc();
 
     /** Appends element \a v to the end of the list */
     virtual void append(const TemplateVariant &v);
 
   private:
+    /** Creates a list */
+    TemplateList();
+    /** Destroys the list */
+   ~TemplateList();
+
     friend class TemplateListConstIterator;
     class Private;
     Private *p;
@@ -302,6 +332,12 @@ class TemplateStructIntf
      *  @param[in] name The name of the field.
      */
     virtual TemplateVariant get(const char *name) const = 0;
+
+    /** Increase object's reference count */
+    virtual int addRef() = 0;
+
+    /** Decreases object's referenc count, destroy object if 0 */
+    virtual int release() = 0;
 };
 
 
@@ -309,13 +345,13 @@ class TemplateStructIntf
 class TemplateStruct : public TemplateStructIntf
 {
   public:
-    /** Creates a struct */
-    TemplateStruct();
-    /** Destroys the struct */
-    virtual ~TemplateStruct();
-
     // TemplateStructIntf methods
     virtual TemplateVariant get(const char *name) const;
+    virtual int addRef();
+    virtual int release();
+
+    /** Creates an instance with ref count set to 0. */
+    static TemplateStruct *alloc();
 
     /** Sets the value the field of a struct
      *  @param[in] name The name of the field.
@@ -323,7 +359,13 @@ class TemplateStruct : public TemplateStructIntf
      */
     virtual void set(const char *name,const TemplateVariant &v);
 
+
   private:
+    /** Creates a struct */
+    TemplateStruct();
+    /** Destroys the struct */
+    virtual ~TemplateStruct();
+
     class Private;
     Private *p;
 };