initial version

1 files changed, 975 insertions, 0 deletions

diff --git a/src/index.cpp b/src/index.cpp
new file mode 100644
index 0000000..d472542
--- /dev/null
+++ b/src/index.cpp
@@ -0,0 +1,975 @@
+/******************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997-1999 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+
+#include <qtstream.h>
+#include <qdatetm.h>
+#include <qdir.h>
+#include <stdlib.h>
+
+#include "message.h"
+#include "index.h"
+#include "doxygen.h"
+#include "scanner.h"
+#include "code.h"
+#include "config.h"
+#include "filedef.h"
+#include "outputlist.h"
+#include "util.h"
+#include "groupdef.h"
+#include "language.h"
+
+//----------------------------------------------------------------------------
+
+// strips w from s iff s starts with w
+bool stripWord(QString &s,QString w)
+{
+  bool success=FALSE;
+  if (s.left(w.length())==w) 
+  {
+    success=TRUE;
+    s=s.right(s.length()-w.length());
+  }
+  return success;
+}
+
+//----------------------------------------------------------------------------
+// some quasi intelligent brief description abbreviator :^)
+QString abbreviate(const char *s,const char *name)
+{
+  QString result=s;
+  QString start1=(QString)"The "+name+" class ";
+  QString start2=(QString)"The "+name+" widget ";
+  QString start3=(QString)"The "+name+" file ";
+  result=result.simplifyWhiteSpace();
+  // strip trailing .
+  if (result.length()>0 && result.at(result.length()-1)=='.') 
+    result=result.left(result.length()-1);
+  bool found=FALSE;
+  found = found || stripWord(result,start1);
+  found = found || stripWord(result,start2);
+  found = found || stripWord(result,start3);
+  if (found)
+  {
+    bool found=FALSE;
+    found = found || stripWord(result,"is ");
+    found = found || stripWord(result,"provides ");
+    found = found || stripWord(result,"specifies ");
+    found = found || stripWord(result,"contains ");
+    found = found || stripWord(result,"represents ");
+    if (found)
+    {
+      stripWord(result,"a ");
+      stripWord(result,"an ");
+      stripWord(result,"the ");
+    }
+  }
+  if (result.length()>0)
+  {
+    int c=result[0];
+    if (c>='a' && c<='z') c+='A'-'a';
+    result[0]=c;
+  }
+  return result;
+}
+
+//----------------------------------------------------------------------------
+
+void initBaseClassHierarchy(BaseClassList *bcl)
+{
+  BaseClassListIterator bcli(*bcl);
+  for ( ; bcli.current(); ++bcli)
+  {
+    ClassDef *cd=bcli.current()->classDef;
+    if (cd->baseClasses()->count()==0) // no base classes => new root
+    {
+      initBaseClassHierarchy(cd->baseClasses());
+    }
+    cd->visited=FALSE;
+  }
+}
+
+//----------------------------------------------------------------------------
+
+void initClassHierarchy(ClassList *cl)
+{
+  ClassListIterator cli(*cl);
+  ClassDef *cd;
+  for ( ; (cd=cli.current()); ++cli)
+  {
+    cd->visited=FALSE;
+    initBaseClassHierarchy(cd->baseClasses());
+  }
+}
+
+//----------------------------------------------------------------------------
+
+bool hasVisibleRoot(BaseClassList *bcl)
+{
+  BaseClassListIterator bcli(*bcl);
+  for ( ; bcli.current(); ++bcli)
+  {
+    ClassDef *cd=bcli.current()->classDef;
+    if (cd->isVisibleExt()) return TRUE;
+    hasVisibleRoot(cd->baseClasses());
+  }
+  return FALSE;
+}
+
+//----------------------------------------------------------------------------
+
+void writeClassTree(OutputList &ol,BaseClassList *bcl,bool hideSuper)
+{
+  BaseClassListIterator bcli(*bcl);
+  bool started=FALSE;
+  for ( ; bcli.current() ; ++bcli)
+  {
+    ClassDef *cd=bcli.current()->classDef;
+    if (cd->isVisibleExt() && hasVisibleRoot(cd->baseClasses()))
+    {
+      if (!started)
+      {
+        ol.startIndexList();
+        started=TRUE;
+      }
+      //printf("Passed...\n");
+      if (cd->hasDocumentation() || cd->isReference())
+      {
+        ol.writeIndexItem(cd->getReference(),cd->classFile(),cd->name());
+        if (cd->isReference()) 
+        { 
+          ol.startTypewriter(); 
+          ol.docify(" [external]");
+          ol.endTypewriter();
+        }
+      }
+      else
+      {
+        ol.writeIndexItem(0,0,cd->name());
+      }
+      if (!cd->visited && !hideSuper && cd->superClasses()->count()>0)
+      {
+        writeClassTree(ol,cd->superClasses(),cd->visited);
+        cd->visited=TRUE;
+      }
+    }
+  }
+  if (started) ol.endIndexList(); 
+}
+
+//----------------------------------------------------------------------------
+
+void writeClassHierarchy(OutputList &ol)
+{
+  initClassHierarchy(&classList);
+
+  bool started=FALSE;
+  ClassListIterator cli(classList);
+  for (;cli.current(); ++cli)
+  {
+    ClassDef *cd=cli.current();
+    if (!hasVisibleRoot(cd->baseClasses()))
+    {
+      if (cd->isVisibleExt())
+      {
+        if (!started)
+        {
+          ol.startIndexList();
+          started=TRUE;
+        }
+        if (cd->hasDocumentation() || cd->isReference())
+        {
+          ol.writeIndexItem(cd->getReference(),cd->classFile(),cd->name());
+          if (cd->isReference()) 
+          {
+            ol.startTypewriter(); 
+            ol.docify(" [external]");
+            ol.endTypewriter();
+          }
+        }
+        else
+        {
+          ol.writeIndexItem(0,0,cd->name());
+        }
+      }
+      if (!cd->visited && cd->superClasses()->count()>0) 
+      {
+        writeClassTree(ol,cd->superClasses(),cd->visited);
+        cd->visited=TRUE;
+      }
+    }
+  }
+  if (started) ol.endIndexList();
+}
+
+//----------------------------------------------------------------------------
+
+int countClassHierarchy()
+{
+  initClassHierarchy(&classList);
+  int count=0;
+  ClassListIterator cli(classList);
+  for ( ; cli.current(); ++cli)
+  {
+    if (cli.current()->superClasses()->count()>0) count++;
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeHierarchicalIndex(OutputList &ol)
+{
+  if (hierarchyClasses==0) return;
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"hierarchy","Hierarchical Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trClassHierarchy());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trClassHierarchyDescription());
+  ol.newParagraph();
+  writeClassHierarchy(ol);
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countFileList()
+{
+  int count=0;
+  FileNameListIterator fnli(inputNameList);
+  FileName *fn;
+  for (;(fn=fnli.current());++fnli)
+  {
+    FileNameIterator fni(*fn);
+    FileDef *fd;
+    for (;(fd=fni.current());++fni)
+    {
+      if (fd->hasDocumentation()) count++;
+    }
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeFileIndex(OutputList &ol)
+{
+  if (documentedFiles==0) return;
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"files","File Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trFileList());
+  endTitle(ol,0);
+  ol.newParagraph();
+  parseDoc(ol,0,0,theTranslator->trFileListDescription(extractAllFlag));
+  ol.newParagraph();
+
+  ol.startIndexList();
+  FileName *fn=inputNameList.first();
+  while (fn)
+  {
+    FileDef *fd=fn->first();
+    while (fd)
+    {
+      if (fd->hasDocumentation() && !fd->isReference())
+      {
+        //ol.writeIndexItem(fd->getReference(),fd->diskName(),
+        //    fd->name());
+        QString path;
+        if (fullPathNameFlag) 
+        {
+          path=fd->getPath().copy();
+          // strip part of the path
+          if (path.left(stripFromPath.length())==stripFromPath)
+            path=path.right(path.length()-stripFromPath.length());
+        }
+
+        ol.writeStartAnnoItem("file",
+                              fd->diskName(),
+                              path,
+                              fd->name()
+                             );
+        ol.docify(" (");
+        if (fd->briefDescription())
+        {
+          OutputList briefOutput(&ol);
+          parseDoc(briefOutput,0,0,
+              abbreviate(fd->briefDescription(),fd->name()));
+          ol+=briefOutput;
+        }
+        else
+        {
+          ol.startEmphasis();
+          parseDoc(ol,0,0,theTranslator->trNoDescriptionAvailable());
+          ol.endEmphasis();
+        }
+        ol.docify(")");
+        ol.writeEndAnnoItem(fd->name());
+      }
+      fd=fn->next();
+    }
+    fn=inputNameList.next();
+  }
+  ol.endIndexList();
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countNamespaceList()
+{
+  int count=0;
+  NamespaceListIterator nli(namespaceList);
+  NamespaceDef *nd;
+  for (;(nd=nli.current());++nli)
+  {
+    if (nd->hasDocumentation()) count++;
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeNamespaceIndex(OutputList &ol)
+{
+  if (documentedNamespaces==0) return;
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"namespaces","Namespace Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trNamespaceList());
+  endTitle(ol,0);
+  ol.newParagraph();
+  parseDoc(ol,0,0,theTranslator->trNamespaceListDescription(extractAllFlag));
+  ol.newParagraph();
+
+  ol.startIndexList();
+  NamespaceDef *nd=namespaceList.first();
+  while (nd)
+  {
+    if (nd->hasDocumentation())
+    {
+      ol.writeStartAnnoItem("namespace",nd->namespaceFile(),0,nd->name());
+      ol.docify(" (");
+      if (nd->briefDescription())
+      {
+        OutputList briefOutput(&ol);
+        parseDoc(briefOutput,nd->name(),0,
+                      abbreviate(nd->briefDescription(),nd->name()));
+        ol+=briefOutput;
+      }
+      else
+      {
+        ol.startEmphasis();
+        parseDoc(ol,0,0,theTranslator->trNoDescriptionAvailable());
+        ol.endEmphasis();
+      }
+      ol.docify(")");
+      ol.writeEndAnnoItem(nd->name());
+    }
+    nd=namespaceList.next();
+  }
+  ol.endIndexList();
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countAnnotatedClasses()
+{
+  int count=0;
+  //ClassDef *cd=classList.first();
+  ClassListIterator cli(classList);
+  ClassDef *cd;
+  for (;(cd=cli.current());++cli)
+  {
+    if (!cd->isReference() && cd->isVisible()) 
+    { 
+      //printf("Annotated class %s\n",cd->name().data()); 
+      count++; 
+    }
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------
+
+void writeAnnotatedClassList(OutputList &ol)
+{
+  ol.startIndexList(); 
+  //ClassDef *cd=classList.first();
+  //while (cd)
+  ClassListIterator cli(classList);
+  ClassDef *cd;
+  for (;(cd=cli.current());++cli)
+  {
+    if (!cd->isReference() && 
+        //!cd->name().isEmpty() && cd->name()[0]!='@' && 
+        //(cd->protection()!=Private || extractPrivateFlag) &&
+        //(cd->hasDocumentation() || !hideClassFlag)
+        cd->isVisible()
+       )
+    {
+      QString type;
+      switch (cd->compoundType())
+      {
+        case ClassDef::Class:  type="class";   break;
+        case ClassDef::Struct: type="struct";  break;
+        case ClassDef::Union:  type="union";   break;
+        default:               type="unknown"; break; // an error
+      }
+      ol.writeStartAnnoItem(type,cd->classFile(),0,cd->name());
+      ol.docify(" (");
+      if (cd->briefDescription())
+      {
+        OutputList briefOutput(&ol);
+        parseDoc(briefOutput,cd->name(),0,
+                      abbreviate(cd->briefDescription(),cd->name()));
+        ol+=briefOutput;
+      }
+      else
+      {
+        ol.startEmphasis();
+        parseDoc(ol,0,0,theTranslator->trNoDescriptionAvailable());
+        ol.endEmphasis();
+      }
+      ol.docify(")");
+      ol.writeEndAnnoItem(cd->name());
+    }
+    cd=classList.next(); 
+  }
+  ol.endIndexList();
+}
+
+//----------------------------------------------------------------------------
+
+void writeAnnotatedIndex(OutputList &ol)
+{
+  if (annotatedClasses==0) return;
+  
+  //if (classList.count()==0) return;
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"annotated","Annotated Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trCompoundList());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trCompoundListDescription());
+  writeAnnotatedClassList(ol);
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeMemberList(OutputList &ol)
+{
+  ol.startItemList();
+  MemberName *mn=memberNameList.first();
+  while (mn)
+  {
+    MemberDef *md=mn->first();
+    bool found=FALSE;
+    bool isFunc=FALSE;
+    while (md && !found)
+    {
+      ClassDef *cd;
+      if ((md->isFriend() || md->protection()!=Private || extractPrivateFlag) && 
+          !md->isReference() && md->hasDocumentation() &&
+           md->name()[0]!='@' && (cd=md->memberClass()) &&
+           cd->isVisible()
+         ) 
+      { 
+        found=TRUE; 
+        isFunc=md->isFunction(); 
+      }
+      md=mn->next();
+    }
+    if (found)
+    {
+      ol.writeListItem();
+      ol.docify(substituteClassNames(mn->memberName()));
+      if (isFunc) ol.docify("()");
+      ol.writeString("\n");
+
+      int count=0;
+      md=mn->first();
+      QString prevName;
+      while (md)
+      {
+        ClassDef *cd=md->memberClass();
+        if (cd && (md->isFriend() || md->protection()!=Private || extractPrivateFlag) && 
+            !md->isReference() && md->hasDocumentation() && 
+            prevName!=cd->name() && 
+            cd->isVisible()
+           )
+        {
+          if (count==0) 
+            ol.docify(": ");
+          else 
+            ol.docify(", ");
+          ol.writeObjectLink(cd->getReference(),cd->classFile(),md->anchor(),
+                            cd->name());
+          count++;
+          prevName=cd->name();
+        }
+        md=mn->next();
+      }
+    }
+    mn=memberNameList.next();
+  }
+  ol.endItemList();
+}
+
+//----------------------------------------------------------------------------
+
+int countMemberList()
+{
+  int count=0;
+  MemberName *mn=memberNameList.first();
+  while (mn)
+  {
+    MemberDef *md=mn->first();
+    bool found=FALSE;
+    MemberDef *otherMd=0;
+    ClassDef *cd;
+    while (md && !found)
+    {
+      if ((md->isFriend() || md->protection()!=Private || extractPrivateFlag) && 
+          !md->isReference() && !md->isRelated() && md->hasDocumentation() &&
+          md->name()[0]!='@' && (cd=md->memberClass()) && cd->isVisible()) 
+        otherMd=md;
+      if ((md->isFriend() || md->protection()!=Private || extractPrivateFlag) && 
+          !md->isReference() && md->isRelated() && md->hasDocumentation() &&
+          md->name()[0]!='@' && (cd=md->memberClass()) && cd->isVisible())
+        found=TRUE;
+      else
+        md=mn->next();
+    }
+    if (found || otherMd) count++;
+    mn=memberNameList.next();
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeMemberIndex(OutputList &ol)
+{
+  if (memberNameList.count()==0) return;
+  ol.disable(OutputGenerator::Man);
+  ol.disable(OutputGenerator::Latex);
+  startFile(ol,"functions","Compound Member Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trCompoundMembers());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trCompoundMembersDescription(extractAllFlag));
+  writeMemberList(ol);
+  endFile(ol);
+  ol.enable(OutputGenerator::Latex);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeFunctionList(OutputList &ol)
+{
+  ol.startItemList();
+  MemberName *mn=functionNameList.first();
+  while (mn)
+  {
+    MemberDef *md=mn->first();
+    bool found=FALSE;
+    while (md && !found)
+    {
+      FileDef *fd=md->getFileDef() ? md->getFileDef() : md->getFileDec();
+      bool hasDocs = 
+         (md->getFileDef() && md->getFileDef()->hasDocumentation()) ||
+         (md->getFileDec() && md->getFileDec()->hasDocumentation());
+      
+      if (fd && hasDocs && 
+          !md->isReference() && 
+          md->hasDocumentation() && 
+          md->name()[0]!='@') found=TRUE;
+      else
+        md=mn->next();
+    }
+    if (found) // function is documented
+    {
+      ol.writeListItem();
+      ol.docify(md->name());
+      if (md->isFunction()) ol.docify("()");
+      ol.writeString("\n");
+
+      int count=0;
+      md=mn->first();
+      QString prevName;
+      while (md)
+      {
+        FileDef *fd=md->getFileDef() ? md->getFileDef() : md->getFileDec();
+        bool hasDocs = 
+         (md->getFileDef() && md->getFileDef()->hasDocumentation()) ||
+         (md->getFileDec() && md->getFileDec()->hasDocumentation());
+        if (fd && hasDocs && 
+            !md->isReference() && 
+            md->hasDocumentation() && 
+            md->name()[0]!='@' && 
+            prevName!=fd->name())
+        {
+          if (count==0) 
+            ol.docify(": ");
+          else 
+            ol.docify(", ");
+          QString baseName=fd->name().copy();
+          //int s;
+          //if ((s=baseName.findRev("/"))!=-1) 
+          //  baseName=baseName.right(baseName.length()-s-1);
+          ol.writeObjectLink(fd->getReference(),
+              fd->diskName(),md->anchor(), baseName);
+          count++;
+          prevName=fd->name();
+        }
+        md=mn->next();
+      }
+    }
+    mn=functionNameList.next();
+  }
+  ol.endItemList();
+}
+
+//----------------------------------------------------------------------------
+
+int countFunctionList()
+{
+  int count=0;
+  MemberName *mn=functionNameList.first();
+  while (mn)
+  {
+    MemberDef *md=mn->first();
+    FileDef *fd;
+    bool found=FALSE;
+    while (md && !found)
+    {
+      if (!md->isReference() && md->hasDocumentation() && 
+          md->name()[0]!='@' && 
+          (((fd=md->getFileDef()) && fd->hasDocumentation())
+            || 
+           ((fd=md->getFileDec()) && fd->hasDocumentation())
+          )
+         ) 
+        found=TRUE;
+      else
+        md=mn->next();
+    }
+    if (found) count++;
+    mn=functionNameList.next();
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeFunctionIndex(OutputList &ol)
+{
+  if (documentedFunctions==0) return;
+  ol.disable(OutputGenerator::Man);
+  ol.disable(OutputGenerator::Latex);
+  startFile(ol,"globals","File Member Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trFileMembers());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trFileMembersDescription(extractAllFlag));
+  writeFunctionList(ol);
+  endFile(ol);
+  ol.enable(OutputGenerator::Latex);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeHeaderFileList(OutputList &ol)
+{
+  if (includeFiles.count()>0)
+  {
+    ol.startItemList();
+    FileDef *fd=includeFiles.first();
+    while (fd)
+    {
+      ol.writeListItem();
+      QString path;
+      if (fullPathNameFlag) 
+      {
+        path=fd->getPath().copy();
+        // strip part of the path
+        if (path.left(stripFromPath.length())==stripFromPath)
+          path=path.right(path.length()-stripFromPath.length());
+      }
+      if (!path.isEmpty()) ol.docify(path);
+      ol.writeObjectLink(0,fd->includeName(),0,fd->name());
+      ol.writeString("\n");
+      fd=includeFiles.next();
+    }  
+    ol.endItemList();
+  }
+}
+
+//----------------------------------------------------------------------------
+
+void writeHeaderIndex(OutputList &ol)
+{
+  if (includeFiles.count()==0) return;
+  ol.disable(OutputGenerator::Man);
+  ol.disable(OutputGenerator::Latex);
+  startFile(ol,"headers","Header File Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trHeaderFiles());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trHeaderFilesDescription());
+  writeHeaderFileList(ol);
+  endFile(ol);
+  ol.enable(OutputGenerator::Latex);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeExampleIndex(OutputList &ol)
+{
+  if (exampleList.count()==0) return;
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"examples","Example Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trExamples());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trExamplesDescription());
+  ol.startIndexList();
+  PageInfo *pi=exampleList.first();
+  while (pi)
+  {
+    ol.writeListItem();
+    QString n=convertSlashes(pi->name,TRUE)+"-example";
+    if (!pi->title.isEmpty())
+    {
+      ol.writeObjectLink(0,n,0,pi->title);
+    }
+    else
+    {
+      ol.writeObjectLink(0,n,0,pi->name);
+    }
+    ol.writeString("\n");
+    pi=exampleList.next();
+  }
+  ol.endIndexList();
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writePageIndex(OutputList &ol)
+{
+  if (pageList.count()==0) return;
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"pages","Page Index");
+  startTitle(ol);
+  ol.docify(projectName+" "+theTranslator->trRelatedPages());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trRelatedPagesDescription());
+  ol.startIndexList();
+  PageInfo *pi=pageList.first();
+  while (pi)
+  {
+    QString pageName;
+    if (caseSensitiveNames)
+      pageName=pi->name.copy();
+    else
+      pageName=pi->name.lower();
+    ol.writeListItem();
+    ol.writeObjectLink(0,pageName,0,pi->name);
+    ol.writeString("\n");
+    pi=pageList.next();
+  }
+  ol.endIndexList();
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countGroupList()
+{
+  int count=0;
+  GroupListIterator gli(groupList);
+  GroupDef *gd;
+  for (;(gd=gli.current());++gli)
+  {
+    if (gd->countMembers()>0) count++;
+    gd=groupList.next();
+  }
+  return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeGroupList(OutputList &ol)
+{
+  ol.startDescription();
+  GroupListIterator gli(groupList);
+  GroupDef *gd;
+  for (;(gd=gli.current());++gli)
+  {
+    if (gd->countMembers()>0)
+    {
+      ol.startDescItem();
+      ol.startTextLink(gd->groupFile(),0);
+      parseDoc(ol,0,0,gd->groupTitle());
+      ol.endTextLink();
+      ol.endDescItem();
+      parseDoc(ol,0,0,gd->briefDescription());
+      ol.newParagraph();
+    }
+  }
+  ol.endDescription();
+}
+
+//----------------------------------------------------------------------------
+
+void writeGroupIndex(OutputList &ol)
+{
+  if (documentedGroups==0) return; 
+  ol.disable(OutputGenerator::Man);
+  startFile(ol,"modules","Module Index");
+  startTitle(ol);
+  parseDoc(ol,0,0,projectName+" "+theTranslator->trModules());
+  endTitle(ol,0);
+  parseDoc(ol,0,0,theTranslator->trModulesDescription());
+  writeGroupList(ol);
+  endFile(ol);
+  ol.enable(OutputGenerator::Man);
+}
+
+void writeIndex(OutputList &ol)
+{
+  // save old generator state
+  bool manEnabled = ol.isEnabled(OutputGenerator::Man);
+  bool texEnabled = ol.isEnabled(OutputGenerator::Latex);
+  bool htmEnabled = ol.isEnabled(OutputGenerator::Html);
+
+  QString projPrefix;
+  if (!projectName.isEmpty())
+  {
+    projPrefix=projectName+" ";
+  }
+  // write HTML index
+  ol.disable(OutputGenerator::Man);
+  ol.disable(OutputGenerator::Latex);
+  ol.startFile("index","Main Index",FALSE);
+  if (!noIndexFlag) writeQuickLinks(ol,TRUE);
+  ol.startTitleHead();
+  parseDoc(ol,0,0,projPrefix+theTranslator->trDocumentation());
+  ol.endTitleHead(0);
+  ol.newParagraph();
+  if (!projectNumber.isEmpty())
+  {
+    ol.startProjectNumber();
+    parseDoc(ol,0,0,projectNumber);
+    ol.endProjectNumber();
+  }
+  if (noIndexFlag) writeQuickLinks(ol,FALSE);
+  endFile(ol);
+  ol.disable(OutputGenerator::Html);
+  
+  // write LaTeX index
+  ol.enable(OutputGenerator::Latex);
+  ol.startFile("refman",0,FALSE);
+  ol.startIndexSection(isTitlePageStart);
+  parseDoc(ol,0,0,projPrefix+theTranslator->trReferenceManual());
+  if (!projectNumber.isEmpty())
+  {
+    ol.startProjectNumber(); 
+    parseDoc(ol,0,0,projectNumber);
+    ol.endProjectNumber();
+  }
+  ol.endIndexSection(isTitlePageStart);
+  ol.startIndexSection(isTitlePageAuthor);
+  parseDoc(ol,0,0,theTranslator->trGeneratedBy());
+  ol.endIndexSection(isTitlePageAuthor);
+  if (documentedGroups>0)
+  {
+    ol.startIndexSection(isModuleIndex);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trModuleIndex());
+    ol.endIndexSection(isModuleIndex);
+  }
+  if (hierarchyClasses>0)
+  {
+    ol.startIndexSection(isClassHierarchyIndex);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trHierarchicalIndex());
+    ol.endIndexSection(isClassHierarchyIndex);
+  }
+  if (annotatedClasses>0)
+  {
+    ol.startIndexSection(isCompoundIndex);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trCompoundIndex());
+    ol.endIndexSection(isCompoundIndex);
+  }
+  if (documentedFiles>0)
+  {
+    ol.startIndexSection(isFileIndex);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trFileIndex());
+    ol.endIndexSection(isFileIndex);
+  }
+  if (documentedGroups>0)
+  {
+    ol.startIndexSection(isModuleDocumentation);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trModuleDocumentation());
+    ol.endIndexSection(isModuleDocumentation);
+  }
+  if (annotatedClasses>0)
+  {
+    ol.startIndexSection(isClassDocumentation);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trClassDocumentation());
+    ol.endIndexSection(isClassDocumentation);
+  }
+  if (documentedFiles>0)
+  {
+    ol.startIndexSection(isFileDocumentation);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trFileDocumentation());
+    ol.endIndexSection(isFileDocumentation);
+  }
+  if (exampleList.count()>0)
+  {
+    ol.startIndexSection(isExampleDocumentation);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trExampleDocumentation());
+    ol.endIndexSection(isExampleDocumentation);
+  }
+  if (pageList.count()>0)
+  {
+    ol.startIndexSection(isPageDocumentation);
+    parseDoc(ol,0,0,projPrefix+theTranslator->trPageDocumentation());
+    ol.endIndexSection(isPageDocumentation);
+  }
+  ol.endIndexSection(isEndIndex);
+  endFile(ol);
+
+  // restore generator state
+  if (manEnabled) ol.enable(OutputGenerator::Man); 
+             else ol.disable(OutputGenerator::Man);
+  if (texEnabled) ol.enable(OutputGenerator::Latex);
+             else ol.disable(OutputGenerator::Latex);
+  if (htmEnabled) ol.enable(OutputGenerator::Html);
+             else ol.disable(OutputGenerator::Html);
+}