initial version

1 files changed, 3763 insertions, 0 deletions

diff --git a/src/doxygen.cpp b/src/doxygen.cpp
new file mode 100644
index 0000000..3d641ef
--- /dev/null
+++ b/src/doxygen.cpp
@@ -0,0 +1,3763 @@
+/******************************************************************************
+ *
+ * $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 <qstring.h>
+#include <qfileinf.h>
+#include <qfile.h>
+#include <qdir.h>
+#include <qdict.h>
+#include <qregexp.h>
+#include <qstrlist.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+#include "version.h"
+#include "doxygen.h"
+#include "scanner.h"
+#include "entry.h"
+#include "index.h"
+#include "logos.h"
+#include "instdox.h"
+#include "message.h"
+#include "code.h"
+#include "config.h"
+#include "util.h"
+#include "pre.h"
+#include "tag.h"
+
+#include "outputlist.h"
+#include "declinfo.h"
+#include "htmlgen.h"
+#include "latexgen.h"
+#include "mangen.h"
+#include "language.h"
+#include "debug.h"
+
+#if defined(_MSC_VER)
+#define popen _popen
+#endif
+
+
+// lists
+ClassList      classList;          // list of all documented classes
+NamespaceList  namespaceList;      // list of all namespaces
+PageList       exampleList;        // list of all example files
+PageList       pageList;           // list of all related documentation pages
+MemberNameList memberNameList;     // list of class member + related functions
+MemberNameList functionNameList;   // list of all unrelated functions
+FileNameList   inputNameList;      // list of all input files
+StringList     inputFiles;         
+FileList       includeFiles;
+GroupList      groupList;          // list of all groups
+FormulaList    formulaList;        // list of all formulas
+
+// dictionaries
+PageDict       pageDict(1009);          // dictionary of all doc pages
+PageDict       exampleDict(1009);       // dictionary of all examples
+ClassDict      classDict(1009);         // dictionary of all documented classes
+NamespaceDict  namespaceDict(257);      // dictionary of all documented namespaces
+MemberNameDict memberNameDict(10007);   // dictionary of all member names
+MemberNameDict functionNameDict(10007); // dictionary of all functions
+StringDict     substituteDict(1009);    // dictionary of class name substitutes
+SectionDict    sectionDict(257);        // dictionary of all page sections
+FileNameDict   inputNameDict(1009);     // dictionary of sections
+StringDict     excludeNameDict(1009);   // dictionary of sections
+FileNameDict   includeNameDict(1009);   // dictionary of include names
+FileNameDict   exampleNameDict(1009);   // dictionary of examples
+FileDict       includeDict(1009);       // dictionary of include files
+DefineDict     defineDict(10007);       // dictionary of all defines
+StringDict     typedefDict(1009);       // dictionary of all typedefs
+GroupDict      groupDict(257);          // dictionary of all groups
+FormulaDict    formulaDict(1009);       // dictionary of all formulas
+FormulaDict    formulaNameDict(1009);   // dictionary of the label name of all formulas
+
+OutputList     *outputList;           // list of output generating objects
+  
+//bool           unrelatedFunctionsUsed;
+
+//ClassDef unrelatedClass("nothing",ClassDef::Class); 
+                                       // dummy class for unrelated functions
+
+int annotatedClasses;
+int hierarchyClasses;
+int documentedFunctions;
+int documentedMembers;
+int documentedFiles;
+int documentedGroups;
+int documentedNamespaces;
+
+QTextStream tagFile;
+
+void addMemberDocs(Entry *root,MemberDef *md, const char *funcDecl,
+                        bool over_load);
+
+
+//----------------------------------------------------------------------
+// Returns the standard string that is generated when the \overload
+// command is used.
+
+const char *getOverloadDocs()
+{
+  return "This is an overloaded member function, "
+         "provided for convenience. It differs from the above "
+         "function only in what argument(s) it accepts.";
+}
+      
+//----------------------------------------------------------------------------
+
+
+void buildGroupList(Entry *root)
+{
+  if (root->section==Entry::GROUPDOC_SEC && root->name.length()>0)
+  {
+    //printf("Found group %s title=`%s'\n",root->name.data(),root->type.data());
+    
+    GroupDef *gd;
+    
+    if ((gd=groupDict[root->name]))
+    {
+      warn("Warning: group %s already documented\n"
+           "         skipping documentation in file %s at line %d\n",
+           root->name.data(),root->fileName.data(),root->startLine);
+    }
+    else
+    {
+      gd = new GroupDef(root->name,root->type);
+      gd->setBriefDescription(root->brief);
+      gd->setDocumentation(root->doc);
+      groupList.inSort(gd);
+      groupDict.insert(root->name,gd);
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildGroupList(e);
+  }
+}
+
+//----------------------------------------------------------------------
+
+//void computeGroupRelations(Entry *root)
+//{
+//  if (root->section==Entry::GROUPDOC_SEC && root->name.length()>0)
+//  {
+//    GroupDef *gd;
+//    
+//    if ((gd=groupDict[root->name]))
+//    {
+//      QListIterator<QString> sli(*root->groups);
+//      QString *s;
+//      for (;(s=sli.current());++sli)
+//      {
+//        GroupDef *pgd;
+//        if (s->length()>0 && (pgd=groupDict[*s]))
+//        {
+//          pgd->addGroup(gd);
+//          printf("Group %s: in group %s\n",gd->groupName(),s->data());
+//        }
+//      }
+//    }
+//  }
+//  EntryListIterator eli(*root->sublist);
+//  Entry *e;
+//  for (;(e=eli.current());++eli)
+//  {
+//    computeGroupRelations(e);
+//  }
+//}
+
+//----------------------------------------------------------------------
+
+void buildFileList(Entry *root)
+{
+  if (((root->section==Entry::FILEDOC_SEC) ||
+      ((root->section & Entry::FILE_MASK) && extractAllFlag)) &&
+      root->name.length()>0
+     )
+  {
+    bool ambig;
+    FileDef *fd=findFileDef(&inputNameDict,root->name,ambig);
+    if (fd && !ambig)
+    {
+      if ((root->doc.length()>0 && fd->documentation()) ||
+          (root->brief.length()>0 && fd->briefDescription()))
+      {
+        warn("Warning: file %s already documented\n"
+            "         skipping documentation in file %s at line %d\n",
+            root->name.data(),root->fileName.data(),root->startLine);
+      }
+      else
+      {
+        fd->setDocumentation(root->doc);
+        fd->setBriefDescription(root->brief); 
+        QListIterator<QString> sli(*root->groups);
+        QString *s;
+        for (;(s=sli.current());++sli)
+        {
+          GroupDef *gd=0;
+          if (s->length()>0 && (gd=groupDict[*s]))
+          {
+            gd->addFile(fd);
+            //printf("File %s: in group %s\n",fd->name().data(),s->data());
+          }
+        }
+      }
+    }
+    else
+    {
+      warn("Warning: the name `%s' supplied as "
+           "the second argument in the \\file statement in file "
+           "%s at line %d ",
+           root->name.data(),
+           root->fileName.data(),
+           root->startLine);
+      if (ambig) // name is ambigious
+      {
+        warn("matches the following input files:\n");
+        showFileDefMatches(&inputNameDict,root->name);
+        warn("Please use a more specific name by "
+             "including a (larger) part of the path!\n");
+      }
+      else // name is not an input file
+        warn("is not an input file\n");
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildFileList(e);
+  }
+}
+
+void addIncludeFile(ClassDef *cd,FileDef *ifd,Entry *root)
+{
+  //printf(">>>>>> includeFile=%s\n",root->includeFile.data());
+
+  bool ambig;
+  FileDef *fd=0;
+  // see if we need to include a verbatim copy of the header file
+  if (!root->includeFile.isNull() && 
+      (fd=findFileDef(&inputNameDict,root->includeFile,ambig))==0
+     )
+  { // explicit request
+    warn("Warning: the name `%s' supplied as "
+        "the second argument in the \\class statement in file "
+        "%s at line %d ",
+        root->includeFile.data(),
+        root->fileName.data(),
+        root->startLine);
+    if (ambig) // name is ambigious
+    {
+      warn("matches the following input files:\n");
+      showFileDefMatches(&inputNameDict,root->includeFile);
+      warn("Please use a more specific name by "
+          "including a (larger) part of the path!\n");
+    }
+    else // name is not an input file
+      warn("is not an input file\n");
+  }
+  else if (root->includeFile.length()==0 && 
+      // see if the file extension makes sense
+      guessSection(root->includeFile)==Entry::HEADER_SEC)
+  { // implicit assumption
+    fd=ifd;
+  }
+
+  // if a file is found, we mark it for verbatim inclusion.
+  if (fd)
+  {
+    //printf("fd->name()=%s fd->absFilePath()=%s\n",fd->name().data(),
+    //                                              fd->absFilePath().data());
+    // set include file definition
+    cd->setIncludeFile(fd);
+    // set include supplied name 
+    cd->setIncludeName(root->includeName);
+    fd->setIncludeName((QString)cd->classFile()+"-include");
+    if (includeDict[fd->absFilePath()]==0) // include not inserted earlier
+    {
+      includeFiles.inSort(fd);
+      includeDict.insert(fd->absFilePath(),fd);
+    }
+  }
+}
+
+/*! Input is a scopeName, output is the scopename split into a
+ *  namespace part (as large as possible) and a classname part.
+ */
+void extractNamespaceName(const QString &scopeName,
+                          QString &className,QString &namespaceName)
+{
+  QString clName=scopeName.copy();
+  QString nsName;
+  if (clName.length()>0 && namespaceDict[clName])
+  { // the whole name is a namespace
+    namespaceName=clName.copy();
+    className.resize(0);
+    return;
+  }
+  int i,p=clName.length()-2;
+  while (p>=0 && (i=clName.findRev("::",p))!=-1) 
+    // see if the first part is a namespace
+  {
+    if (i>0 && namespaceDict[clName.left(i)])
+    {
+      namespaceName=clName.left(i);
+      className=clName.right(clName.length()-i-2);
+      return;
+    } 
+    p=i-2; // try a smaller piece of the scope
+  }
+  className=scopeName.copy();
+  namespaceName.resize(0);
+  return;
+}
+
+static bool addNamespace(Entry *root,ClassDef *cd)
+{
+  // see if this class is defined inside a namespace
+  if (root->section & Entry::COMPOUND_MASK)
+  {
+    Entry *e = root->parent;
+    while (e)
+    {
+      if (e->section==Entry::NAMESPACE_SEC)
+      {
+        NamespaceDef *nd=0;
+        if (!e->name.isEmpty() && (nd=namespaceDict[e->name]))
+        {
+          cd->setNamespace(nd);
+          nd->insertClass(cd);
+          return TRUE;
+        }
+      }
+      e=e->parent;
+    } 
+  }
+  return FALSE;
+}
+
+//----------------------------------------------------------------------
+// build a list of all classes mentioned in the documentation
+// and all classes that have a documentation block before their definition.
+void buildClassList(Entry *root)
+{
+  if (
+       ((root->section & Entry::COMPOUNDDOC_MASK) ||
+       ((root->section & Entry::COMPOUND_MASK))) && 
+       root->name.length()>0
+     )
+  {
+    QString fullName=root->name.copy();
+    if (fullName.length()==0)
+    {
+      // this should not be called
+      warn("Warning: invalid class found in file %s at %d\n",
+                  root->fileName.data(),root->startLine);
+    }
+    else 
+    {
+      //QString className;
+      //QString namespaceName;
+      //extractNamespaceName(fullName,className,namespaceName);
+
+      //printf("Found class %s in %s at line %d\n",fullName.data(),
+      //    root->fileName.data(),root->startLine);
+      // add class name substitution entry iff the class name is alterned by a
+      // define. This is needed to properly document Qt's template classes 
+      // (although, it's quite general)
+      //if (resolveDefines(fullName)!=fullName)
+      //{
+      //  substituteDict.insert(resolveDefines(fullName),new QString(fullName));
+      //}
+
+      bool ambig;
+      ClassDef *cd;
+      if ((cd=getClass(fullName))) 
+      {
+        if (cd->templateArguments()==0)
+        {
+          //printf("existing ClassDef tempArgList=%p\n",root->tArgList);
+          cd->setTemplateArguments(root->tArgList);
+        }
+        if (root->doc.length()>0 || root->brief.length()>0) // block contains docs
+        { 
+          if (cd->documentation()) // class already documented
+          {
+            warn("Warning: class %s already documented\n"
+                 "         skipping documentation in file %s at line %d\n",
+                 fullName.data(),root->fileName.data(),root->startLine);
+          }
+          else // class not documented, use docs in block
+          {
+            cd->setDocumentation(root->doc);
+            cd->setBriefDescription(root->brief);
+            cd->setName(fullName); // change name to match docs
+          }
+        }
+        if (cd->includeFile()==0)
+        {
+          addIncludeFile(cd,
+                         findFileDef(&inputNameDict,root->fileName,ambig),
+                         root
+                        );
+        }
+        addNamespace(root,cd);
+      }
+      else if (fullName[0]!='@' /* && 
+                 (root->doc.length()>0 || 
+                  root->brief.length()>0 || 
+                  extractAllFlag
+                 )*/
+              ) 
+           // new class
+      {
+        int sec=ClassDef::Class; 
+        switch(root->section)
+        {
+          case Entry::UNION_SEC: 
+          case Entry::UNIONDOC_SEC: 
+            sec=ClassDef::Union; break;
+          case Entry::STRUCT_SEC:
+          case Entry::STRUCTDOC_SEC: 
+            sec=ClassDef::Struct; break;
+        }
+        ClassDef *cd=new ClassDef(fullName,sec);
+        cd->setDocumentation(root->doc); // copy docs to definition
+        cd->setBriefDescription(root->brief);
+        //printf("new ClassDef tempArgList=%p\n",root->tArgList);
+        cd->setTemplateArguments(root->tArgList);
+        cd->setProtection(root->protection);
+
+        QListIterator<QString> sli(*root->groups);
+        QString *s;
+        for (;(s=sli.current());++sli)
+        {
+          GroupDef *gd=0;
+          if (s->length()>0 && (gd=groupDict[*s]))
+          {
+            gd->addClass(cd);
+            //printf("Compound %s: in group %s\n",cd->name().data(),s->data());
+          }
+        }
+
+        bool found=addNamespace(root,cd);
+
+        // file definition containing the class cd
+        FileDef *ifd=findFileDef(&inputNameDict,root->fileName,ambig);
+
+        addIncludeFile(cd,ifd,root);
+        
+        // if the class is not in a namespace then we insert 
+        // it in the file definition
+        if (!found && ifd) ifd->insertClass(cd);
+
+        // the empty string test is needed for extract all case
+        cd->setBriefDescription(root->brief);
+        cd->insertUsedFile(root->fileName);
+        // add class to the list
+        classList.inSort(cd);
+        //printf("ClassDict.insert(%s)\n",resolveDefines(fullName).data());
+        //classDict.insert(resolveDefines(fullName),cd);
+        classDict.insert(fullName,cd);
+      }
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildClassList(e);
+  }
+}
+
+//----------------------------------------------------------------------
+// build a list of all namespaces mentioned in the documentation
+// and all namespaces that have a documentation block before their definition.
+void buildNamespaceList(Entry *root)
+{
+  if (
+       (root->section==Entry::NAMESPACE_SEC) ||
+       (root->section==Entry::NAMESPACEDOC_SEC) && 
+       root->name.length()>0
+     )
+  {
+    QString fullName=root->name.copy();
+    if (fullName.length()==0)
+    {
+      // this should not be called
+      warn("Warning: invalid namespace found in file %s at %d\n",
+                  root->fileName.data(),root->startLine);
+    }
+    else 
+    {
+      //printf("Found namespace %s in %s at line %d\n",root->name.data(),
+      //        root->fileName.data(), root->startLine);
+      NamespaceDef *nd;
+      if ((nd=namespaceDict[fullName])) 
+      {
+        if (root->doc.length()>0 || root->brief.length()>0) // block contains docs
+        { 
+          if (nd->documentation().isEmpty() && root->doc.length()>0)
+          {
+            nd->setDocumentation(root->doc);
+            nd->setName(fullName); // change name to match docs
+          }
+          else if (!nd->documentation().isEmpty() && root->doc.length()>0)
+          {
+            warn("Warning: namespace %s already has a detailed description,\n"
+                 "         skipping documentation in file %s at line %d\n",
+                 fullName.data(),root->fileName.data(),root->startLine);
+          }
+          if (nd->briefDescription().isEmpty() && root->brief.length()>0)
+          {
+            nd->setBriefDescription(root->brief);
+            nd->setName(fullName); // change name to match docs
+          }
+          else if (!nd->briefDescription().isEmpty() && root->brief.length()>0)
+          {
+            warn("Warning: namespace %s already has a brief description,\n"
+                 "         skipping documentation in file %s at line %d\n",
+                 fullName.data(),root->fileName.data(),root->startLine);
+          }
+        }
+      }
+      else if (root->doc.length()>0 || 
+               root->brief.length()>0 || 
+               extractAllFlag
+              ) 
+      {
+        NamespaceDef *nd=new NamespaceDef(fullName);
+        nd->setDocumentation(root->doc); // copy docs to definition
+        nd->setBriefDescription(root->brief);
+
+        QListIterator<QString> sli(*root->groups);
+        QString *s;
+        for (;(s=sli.current());++sli)
+        {
+          GroupDef *gd=0;
+          if (s->length()>0 && (gd=groupDict[*s]))
+            gd->addNamespace(nd);
+        }
+
+        bool ambig;
+        // file definition containing the class cd
+        FileDef *fd=findFileDef(&inputNameDict,root->fileName,ambig);
+        // insert the namespace in the file definition
+        if (fd) fd->insertNamespace(nd);
+
+        // the empty string test is needed for extract all case
+        nd->setBriefDescription(root->brief);
+        nd->insertUsedFile(root->fileName);
+        // add class to the list
+        namespaceList.inSort(nd);
+        namespaceDict.insert(fullName,nd);
+      }
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildNamespaceList(e);
+  }
+}
+
+
+//----------------------------------------------------------------------
+// Searches the Entry tree for Variable documentation sections.
+// If found they are stored in their class or in the global list.
+
+void buildVarList(Entry *root)
+{
+  QRegExp re("([^)]*)");
+  int i=-1;
+  if (root->name.length()>0 &&
+      root->type!="class" &&
+      (
+       (root->section==Entry::VARIABLE_SEC 
+       ) ||
+       (root->section==Entry::FUNCTION_SEC && // function variable 
+        !root->type.isNull() && root->type.find(re,0)!=-1 && 
+         root->type.find("operator")==-1 && root->type.find(")(")==-1 
+       )
+      ) 
+     ) // documented variable
+  {
+    Debug::print(Debug::Variables,0,
+                  "VARIABLE_SEC: \n"
+                  "  type=`%s' name=`%s' args=`%s'\n",
+                   root->type.data(),
+                   root->name.data(),
+                   root->args.data()
+                );
+    //printf("root->parent->name=%s\n",root->parent->name.data());
+
+    if (root->type.isNull() && root->name.find("operator")==-1 &&
+        (root->name.find('*')!=-1 || root->name.find('&')!=-1))
+    {
+      // recover from parse error caused by redundant braces
+      root->type=root->name;
+      QRegExp re("[a-z_A-Z][a-z_A-Z0-9]*");
+      int i,l;
+      i=re.match(root->args,0,&l);
+      root->name=root->args.mid(i,l);
+      root->args=root->args.mid(i+l,
+          root->args.find(')',i+l)-i-l);
+      //printf("new: type=`%s' name=`%s' args=`%s'\n",
+      //    root->type.data(),root->name.data(),root->args.data());
+    }
+    else
+    {
+      QRegExp re("([^)]*)");
+      i=root->type.find(re,0);
+      if (i!=-1) // function variable
+      {
+        root->type=root->type.left(root->type.length()-1);
+        root->args.prepend(")");
+      }
+    }
+    
+    QString scope,name=root->name.copy();
+    bool stat=root->stat;
+    ClassDef *cd=0;
+    Entry *p = root->parent;
+    while ((p->section & Entry::COMPOUND_MASK))
+    {
+      if (p->name.length()>0 && p->name[0]!='@')
+      {
+        if (!scope.isEmpty()) scope.prepend("::"); 
+        scope.prepend(p->name);
+      }
+      p=p->parent;
+    }
+    
+    //printf("scope=%s\n",scope.data()); 
+    
+    int ni;
+    if ((ni=root->name.findRev("::"))!=-1)
+    {
+      if (scope.length()>0) scope+="::";
+      scope+=root->name.left(ni);
+      name=root->name.right(root->name.length()-ni-2);
+      stat=TRUE;
+    }
+
+    MemberDef::MemberType mtype;
+    QString type=root->type.stripWhiteSpace();
+    if (type=="@") 
+      mtype=MemberDef::EnumValue;
+    else if (type.left(8)=="typedef ") 
+      mtype=MemberDef::Typedef;
+    else if (type.left(7)=="friend ")
+      mtype=MemberDef::Friend;
+    else
+      mtype=MemberDef::Variable;
+
+    if (scope.length()>0 && name.length()>0 && (cd=getClass(scope)))
+    {
+      
+      Debug::print(Debug::Variables,0,
+                   "  class variable:\n"
+                   "    %s' %s'::`%s' `%s' prot=`%d\n",
+                   root->type.data(),
+                   scope.data(), 
+                   name.data(),
+                   root->args.data(),
+                   root->protection
+                  );
+      // add template names, if the class is a non-specialized template
+      //if (scope.find('<')==-1 && cd->templateArguments())
+      //{
+      //  scope+=cd->getTemplateNameString();
+      //}
+      // generate member definition.
+      QString def;
+      if (root->type.length()>0)
+      {
+        if (mtype==MemberDef::Friend)
+        {
+          def=root->type+" "+name+root->args;
+        }
+        else
+        {
+          def=root->type+" "+scope+"::"+name+root->args;
+        }
+      }
+      else
+      {
+        def=scope+"::"+name+root->args;
+      }
+      if (def.left(7)=="static ") def=def.right(def.length()-7);
+
+      // see if the member is already found in the same scope
+      // (this may be the case for a static member that is initialized
+      //  outside the class)
+      bool found=FALSE;
+      MemberName *mn=memberNameDict[name];
+      if (mn)
+      {
+        MemberDef *md=mn->first();
+        while (md)
+        {
+          if (md->memberClass()==cd) // member already in the scope
+          {
+            addMemberDocs(root,md,def,FALSE);
+            found=TRUE; 
+          }
+          md=mn->next();
+        } 
+      }
+      if (!found) // found a fresh variable
+      {
+        // new member variable, typedef or enum value
+        MemberDef *md=new MemberDef(root->type,name,root->args,0,
+            root->protection,Normal,stat,FALSE,
+            mtype,0,0);
+        md->setMemberClass(cd);
+        md->setDefFile(root->fileName);
+        md->setDefLine(root->startLine);
+        md->setDocumentation(root->doc);
+        md->setBriefDescription(root->brief);
+        md->setDefinition(def);
+
+        // add the member to the global list
+        if (mn)
+        {
+          //printf("Member already found! %s\n",md->name());
+          //addMemberDocs(root,mn->first(),def,FALSE);
+          //delete md;
+          mn->inSort(md);
+        }
+        else // new variable name
+        {
+          mn = new MemberName(name);
+          mn->inSort(md);
+          //printf("Adding memberName=%s\n",mn->memberName());
+          memberNameDict.insert(name,mn);
+          memberNameList.inSort(mn);
+          // add the member to the class
+        }
+        cd->insertMember(md);
+
+        //TODO: insert FileDef instead of filename strings.
+        cd->insertUsedFile(root->fileName);
+      }
+    }
+    else if (name.length()>0) // global variable
+    {
+      Debug::print(Debug::Variables,0,
+                   "  global variable:\n"
+                   "    type=`%s' scope=`%s' name=`%s' args=`%s' prot=`%d\n",
+                   root->type.data(),
+                   scope.data(), 
+                   name.data(),
+                   root->args.data(),
+                   root->protection
+                  );
+      
+      // new global variable, enum value or typedef
+      MemberDef *md=new MemberDef(root->type,name,root->args,0,
+                           Public, Normal,root->stat,FALSE,
+                           mtype,0,0);
+      md->setDefFile(root->fileName);
+      md->setDefLine(root->startLine);
+      md->setDocumentation(root->doc);
+      md->setBriefDescription(root->brief);
+      QString def;
+
+      // see if the function is inside a namespace
+      NamespaceDef *nd = 0;
+      if (root->parent->section == Entry::NAMESPACE_SEC )
+      {
+        nd = namespaceDict[root->parent->name];
+      }
+      if (nd)
+      {
+        nd->insertMember(md); 
+        md->setNamespace(nd);
+      }
+      else
+      {
+        // find file definition
+        FileDef *fd=0;
+        bool ambig;
+        if (root->fileName.length()>0 && 
+            (fd=findFileDef(&inputNameDict,root->fileName,ambig))
+           )
+        {
+          fd->insertMember(md);
+          md->setFileDef(fd); 
+        }
+      }
+      
+      // determine the definition of the global variable
+      if (nd) // variable is inside a namespace, so put the scope 
+              // before the name
+      {
+        if (root->type.length()>0)
+        {
+          def=root->type+" "+nd->name()+"::"+name+root->args;
+        }
+        else
+        {
+          def=nd->name()+"::"+name+root->args;
+        }
+      }
+      else
+      {
+        if (root->type.length()>0)
+        {
+          def=root->type+" "+name+root->args;
+        }
+        else
+        {
+          def=name+root->args;
+        }
+      }
+      if (def.left(7)=="static ") def=def.right(def.length()-7);
+      md->setDefinition(def);
+
+      MemberName *mn;
+      // add member definition to the list of globals 
+      if ((mn=functionNameDict[name]))
+      {
+        mn->inSort(md);
+      }
+      else
+      {
+        mn = new MemberName(name);
+        mn->inSort(md);
+        functionNameDict.insert(name,mn);
+        functionNameList.inSort(mn);
+      }
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    if (e->section!=Entry::ENUM_SEC) buildVarList(e);
+  }
+}
+
+//----------------------------------------------------------------------
+// Searches the Entry tree for Function sections.
+// If found they are stored in their class or in the global list.
+
+void buildMemberList(Entry *root)
+{
+  if (root->section==Entry::FUNCTION_SEC)
+  {
+    Debug::print(Debug::Functions,0,
+                 "FUNCTION_SEC:\n"
+                 "  `%s' `%s'::`%s' `%s' relates=`%s' file=`%s' #targs=%d\n",
+                 root->type.data(),
+                 root->parent->name.data(),
+                 root->name.data(),
+                 root->args.data(),
+                 root->relates.data(),
+                 root->fileName.data(),
+                 root->tArgList ? (int)root->tArgList->count() : -1
+                );
+
+    bool isFriend=root->type.find("friend ")!=-1;
+    //if (isFriend && root->relates.length()==0) 
+    //  root->relates=root->parent->name.copy();
+    if (root->name.length()>0 /* && !isFriend */)
+    {
+      
+      ClassDef *cd=0;
+      // check if this function's parent is a class
+      QRegExp re("([a-zA-Z0-9: ]*[ *]*[ ]*");
+      //printf("root->parent=`%s' cd=%p root->type.find(re,0)=%d\n",
+      //    root->parent->name.data(),getClass(root->parent->name),
+      //    root->type.find(re,0));
+      int i;
+      if (root->parent && 
+          root->parent->name.length()>0 &&
+          (root->parent->section & Entry::COMPOUND_MASK) && 
+          (cd=getClass(root->parent->name)) &&
+          // do some fuzzy things to exclude function pointers 
+          (root->type.isNull() || root->type.find(re,0)==-1 || 
+           root->type.find(")(")!=-1 || root->type.find("operator")!=-1
+          )
+         )
+      {
+        int l;
+        if ((i=re.match(root->type,0,&l))!=-1) // function variable
+        {
+          root->args+=root->type.right(root->type.length()-i-l);
+          root->type=root->type.left(i+l);
+        }
+
+        QString name=removeRedundantWhiteSpace(root->name);
+        if (name.left(2)=="::") name=name.right(name.length()-2);
+
+        MemberDef::MemberType mtype;
+        if (isFriend)        mtype=MemberDef::Friend;
+        else if (root->sig)  mtype=MemberDef::Signal;
+        else if (root->slot) mtype=MemberDef::Slot;
+        else                 mtype=MemberDef::Function;
+        // new member of function, signal or slot.
+        MemberDef *md=new MemberDef(root->type,name,root->args,root->exception,
+                             root->protection,root->virt,root->stat,root->relates.length()>0,
+                             mtype,root->tArgList,root->argList);
+        md->setMemberClass(cd);
+        md->setDefFile(root->fileName);
+        md->setDefLine(root->startLine);
+        md->setDocumentation(root->doc);
+        md->setBriefDescription(root->brief);
+        QString def;
+        if (root->relates.length()>0 || isFriend)
+        {
+          if (root->type.length()>0)
+          {
+            if (root->argList)
+            {
+              def=root->type+" "+name;
+            }
+            else
+            {
+              def=root->type+" "+name+root->args;
+            }
+          }
+          else
+          {
+            if (root->argList)
+            {
+              def=name;
+            }
+            else
+            {
+              def=name+root->args;
+            }
+          }
+        }
+        else
+        {
+          QString scope=root->parent->name.copy();
+          if (root->type.length()>0)
+          {
+            if (root->argList)
+            {
+              def=root->type+" "+scope+"::"+name;
+            }
+            else
+            {
+              def=root->type+" "+scope+"::"+name+root->args;
+            }
+          }
+          else
+          {
+            if (root->argList)
+            {
+              def=scope+"::"+name;
+            }
+            else
+            {
+              def=scope+"::"+name+root->args;
+            }
+          }
+        }
+        if (def.left(7)=="friend ") def=def.right(def.length()-7);
+        md->setDefinition(def);
+
+        Debug::print(Debug::Functions,0,
+                     "  Func Member:\n"
+                     "    `%s' `%s'::`%s' `%s' proto=%d\n"
+                     "    def=`%s'\n",
+                     root->type.data(),
+                     root->parent->name.data(),
+                     root->name.data(),
+                     root->args.data(),
+                     root->proto,
+                     def.data()
+                    );
+
+        // add member to the global list of all members
+        MemberName *mn;
+        if ((mn=memberNameDict[name]))
+        {
+          mn->inSort(md);
+        }
+        else
+        {
+          mn = new MemberName(name);
+          mn->inSort(md);
+          //printf("Adding memberName=%s\n",mn->memberName());
+          memberNameDict.insert(name,mn);
+          memberNameList.inSort(mn);
+        }
+
+        // add member to the class cd
+        cd->insertMember(md);
+        // add file to list of used files
+        cd->insertUsedFile(root->fileName);
+      }
+      else if (root->parent && 
+               !(root->parent->section & Entry::COMPOUND_MASK) &&
+               root->name.find("::")==-1 &&
+               root->relates.length()==0 &&
+               root->type.left(7)!="extern ")
+      // no member => unrelated function 
+      {
+        /* check the uniqueness of the function name in the file.
+         * A file could contain a function prototype and a function definition
+         * or even multiple function prototypes.
+         */
+        bool found=FALSE;
+        MemberName *mn;
+        //MemberDef *fmd;
+        if ((mn=functionNameDict[root->name]))
+        {
+          MemberDef *md=mn->first();
+          while (md && !found)
+          {
+            if (md->getFileDef() && 
+                md->getFileDef()->absFilePath()==root->fileName && 
+                /*matchArguments(md->argsString(),root->args)*/
+                matchArguments(md->argumentList(),root->argList)
+               )
+            {
+              // function already found in the same file, one is probably
+              // a prototype.
+              found=TRUE;
+              if (!md->documentation() && !root->doc.isEmpty())
+              {
+                md->setDocumentation(root->doc);
+              }
+              if (!md->briefDescription() && !root->brief.isEmpty())
+              {
+                md->setBriefDescription(root->brief);
+              }
+            }
+            md=mn->next();
+          }
+        }
+        if (!found) /* global function is unique with respect to the file */
+        {
+          //printf("New function type=`%s' name=`%s' args=`%s'\n",
+          //       root->type.data(),root->name.data(),root->args.data());
+          
+          // new global function
+          QString name=removeRedundantWhiteSpace(root->name);
+          MemberDef *md=new MemberDef(root->type,name,root->args,root->exception,
+              root->protection,root->virt,root->stat,FALSE,
+              MemberDef::Function,root->tArgList,root->argList);
+          md->setDefFile(root->fileName);
+          md->setDefLine(root->startLine);
+          md->setDocumentation(root->doc);
+          md->setBriefDescription(root->brief);
+          md->setPrototype(root->proto);
+          QString def;
+          if (root->type.length()>0)
+          {
+            if (root->argList)
+            {
+              def=root->type+" "+name;
+            }
+            else
+            {
+              def=root->type+" "+name+root->args;
+            }
+          }
+          else
+          {
+            if (root->argList)
+            {
+              def=name.copy();
+            }
+            else
+            {
+              def=name+root->args;
+            }
+          }
+          Debug::print(Debug::Functions,0,
+                     "  Global Function:\n"
+                     "    `%s' `%s'::`%s' `%s' proto=%d\n"
+                     "    def=`%s'\n",
+                     root->type.data(),
+                     root->parent->name.data(),
+                     root->name.data(),
+                     root->args.data(),
+                     root->proto,
+                     def.data()
+                    );
+          md->setDefinition(def);
+
+          // see if the function is inside a namespace
+          NamespaceDef *nd = 0;
+          if (root->parent->section == Entry::NAMESPACE_SEC )
+          {
+            nd = namespaceDict[root->parent->name];
+          }
+          if (nd)
+          {
+            nd->insertMember(md); 
+            md->setNamespace(nd);
+          }
+          else
+          {
+            // find file definition
+            FileDef *fd=0;
+            bool ambig;
+            if (root->fileName.length()>0 && 
+                (fd=findFileDef(&inputNameDict,root->fileName,ambig))
+               )
+            {
+              // add member to the file
+              fd->insertMember(md);
+              md->setFileDef(fd); 
+            }
+          }
+
+          // add member to the list of file members
+          MemberName *mn;
+          if ((mn=functionNameDict[name]))
+          {
+            mn->inSort(md);
+          }
+          else 
+          {
+            mn = new MemberName(name);
+            mn->inSort(md);
+            functionNameDict.insert(name,mn);
+            functionNameList.inSort(mn);
+          }
+        }
+        else
+        {
+          //printf("Function already found!\n");
+        }
+
+        //printf("unrelated function %d `%s' `%s' `%s'\n",
+        //    root->parent->section,root->type.data(),root->name.data(),root->args.data());
+      }
+    }
+    else if (root->name.length()==0)
+    {
+        warn("Warning: Illegal member name found in file %s at line %d\n",
+               root->fileName.data(),root->startLine);
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildMemberList(e);
+  }
+}
+
+//----------------------------------------------------------------------
+
+void findFriends()
+{
+  //printf("findFriends()\n");
+  MemberNameListIterator fnli(functionNameList);
+  MemberName *fn;
+  for (;(fn=fnli.current());++fnli) // for each global function name
+  {
+    //printf("Function name=`%s'\n",fn->memberName());
+    MemberName *mn;
+    if ((mn=memberNameDict[fn->memberName()]))
+    { // there are members with the same name
+      //printf("Function name is also a member name\n");
+      MemberNameIterator fni(*fn);
+      MemberDef *fmd;
+      for (;(fmd=fni.current());++fni) // for each function with that name
+      {
+        MemberNameIterator mni(*mn);
+        MemberDef *mmd;
+        for (;(mmd=mni.current());++mni) // for each member with that name
+        {
+          //printf("Checking for matching arguments 
+          //        mmd->isRelated()=%d mmd->isFriend()=%d mmd->isFunction()=%d\n",
+          //    mmd->isRelated(),mmd->isFriend(),mmd->isFunction());
+          NamespaceDef *nd=mmd->getNamespace();
+          if ((mmd->isFriend() || (mmd->isRelated() && mmd->isFunction())) &&
+              matchArguments(mmd->argumentList(),
+                             fmd->argumentList(),
+                             mmd->memberClass()->name(),
+                             nd ? nd->name().data() : 0
+                            )
+             ) // if the member is related and the arguments match then the 
+               // function is actually a friend.
+          {
+            //printf("Found friend function\n");
+            mergeArguments(mmd->argumentList(),fmd->argumentList());
+            if (fmd->documentation())
+              mmd->setDocumentation(fmd->documentation());
+            else if (mmd->documentation())
+              fmd->setDocumentation(mmd->documentation());
+            if (!mmd->briefDescription() && fmd->briefDescription())
+              mmd->setBriefDescription(fmd->briefDescription());
+            else if (mmd->briefDescription() && !fmd->briefDescription())
+              fmd->setBriefDescription(mmd->briefDescription());
+          }
+        }
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------
+
+void transferFunctionDocumentation()
+{
+  //printf("transferFunctionDocumentation()\n");
+  MemberNameListIterator mnli(functionNameList);
+  MemberName *mn;
+  for (;(mn=mnli.current());++mnli)
+  {
+    MemberDef *md,*mdef=0,*mdec=0;
+    MemberNameIterator mni(*mn);
+    /* find a matching function declaration and definition for this function */
+    for (;(md=mni.current());++mni)
+    {
+      if (md->isPrototype()) mdec=md;
+      if (md->isFunction() && !md->isStatic() && !md->isPrototype()) mdef=md;
+    }
+    if (mdef && mdec && 
+        matchArguments(mdef->argumentList(),mdec->argumentList())
+       ) /* match found */
+    {
+      //printf("Found member %s: def in %s and dec in %s\n",
+      //    mn->memberName(),mdef->getFileDef()->name(),mdec->getFileDef()->name());
+      
+      /* copy documentation between function definition and declaration */
+      if (mdec->briefDescription())
+      {
+        mdef->setBriefDescription(mdec->briefDescription());
+      }
+      else if (mdef->briefDescription())
+      {
+        mdec->setBriefDescription(mdef->briefDescription());
+      }
+      if (mdef->documentation())
+      {
+        mdec->setDocumentation(mdef->documentation());
+      }
+      else if (mdec->documentation())
+      {
+        mdef->setDocumentation(mdec->documentation());
+      }
+    }
+  }
+}
+
+
+//----------------------------------------------------------------------
+// Computes the base and super classes for each class in the tree
+
+void computeClassRelations(Entry *root)
+{
+  if (
+      (
+       (
+        root->section & Entry::COMPOUND_MASK
+       ) 
+       ||
+       (
+        (root->section & Entry::COMPOUNDDOC_MASK) && root->extends->count()>0 
+       )
+      )
+      &&
+       root->name.length()>0
+     )
+  {
+    ClassDef *cd;
+    if ((cd=getClass(root->name)))
+    {
+      //printf("Class %s %d\n",cd->name().data(),root->extends->count());
+      if (!cd->visited)
+      {
+        cd->visited=TRUE; // mark class as used (in case the are multiple classes
+            // with the same name!)
+        if (root->extends->count()>0) // there are base classes
+        {
+          QString scopePrefix;
+          Entry *p=root->parent;
+          // For nested classes the base class could also be nested!
+          // To find the correct scope, we try to prepend the scope to the base
+          // name, starting with the largest, most inner scope.
+          while (p->section&Entry::COMPOUND_MASK)
+          {
+            scopePrefix=p->name+"::";
+            QList<BaseInfo> *baseList=root->extends;
+            BaseInfo *bi=baseList->first();
+            while (bi) // for each base class
+            {
+              QString cName=scopePrefix+bi->name;
+              //printf("Base class %s\n",cName.data());
+              ClassDef *baseClass=getClass(cName);
+              if (baseClass) // base class is documented 
+              {
+                //printf("Adding!\n");
+                // add base class to this class
+                cd->insertBaseClass(baseClass,bi->prot,bi->virt);
+                // add this class as super class to the base class
+                baseClass->insertSuperClass(cd,bi->prot,bi->virt);
+              }
+              //else // base class not documented
+              //{
+              //  warn("Warning: Base class %s referred to in file %s at line %d is not "
+              //      "documented\n",s->data(),root->fileName.data(),root->startLine);
+              //}
+              bi=baseList->next();
+            }
+            p=p->parent; 
+          }
+          // The base class could ofcouse also be a non-nested class
+          QList<BaseInfo> *baseList=root->extends;
+          BaseInfo *bi=baseList->first();
+          while (bi) // for each base class
+          {
+            ClassDef *baseClass=getClass(bi->name);
+            //printf("baseClass %s of %s found (%s and %s)\n",
+            //      bi->name.data(),
+            //      root->name.data(),
+            //      (bi->prot==Private)?"private":((bi->prot==Protected)?"protected":"public"),
+            //      (bi->virt==Normal)?"normal":"virtual"
+            //      );
+            int i;
+            QString templSpec,baseClassName=bi->name.copy();
+            if (!baseClass && (i=bi->name.find('<'))!=-1) 
+              // base class has template specifiers
+            {
+              // TODO: here we should try to find the correct template specialization
+              // but for now, we only look for the unspecializated base class.
+              baseClassName=bi->name.left(i);
+              baseClass=getClass(baseClassName);
+              templSpec=bi->name.right(bi->name.length()-i);
+            }
+            if (baseClass) // base class is documented 
+            {
+              // add base class to this class
+              cd->insertBaseClass(baseClass,bi->prot,bi->virt,templSpec);
+              // add this class as super class to the base class
+              baseClass->insertSuperClass(cd,bi->prot,bi->virt,templSpec);
+            }
+            else // base class not documented
+            {
+              //printf("Found undocumented base class %s\n",bi->name.data());
+              NamespaceDef *nd=cd->getNamespace();
+              if (nd && (baseClass=getClass(nd->name()+"::"+baseClassName))) 
+                // class is defined inside namespace
+              {
+                // add base class to this class
+                cd->insertBaseClass(baseClass,bi->prot,bi->virt,templSpec);
+                // add this class as super class to the base class
+                baseClass->insertSuperClass(cd,bi->prot,bi->virt,templSpec);
+              }
+              else // undocumented base class
+              {
+                baseClass=new ClassDef(bi->name,Entry::CLASS_SEC);
+                // add base class to this class
+                cd->insertBaseClass(baseClass,bi->prot,bi->virt,templSpec);
+                // add this class as super class to the base class
+                baseClass->insertSuperClass(cd,bi->prot,bi->virt,templSpec);
+                // the undocumented base was found in this file
+                baseClass->insertUsedFile(root->fileName);
+                // add class to the list
+                classList.inSort(baseClass);
+                //printf("ClassDict.insert(%s)\n",resolveDefines(fullName).data());
+                //classDict.insert(resolveDefines(bi->name),baseClass);
+                classDict.insert(bi->name,baseClass);
+              }
+            }
+            bi=baseList->next();
+          }
+        }
+//       else // class has no base classes
+//        {
+//          QString resName=resolveDefines(root->name);
+//          int i;
+//          // Check if this class is a template instance of another class.
+//          // If this is the case, we act as if this class `inherits' from the
+//          // template class.
+//          if ((i=resName.find('<'))!=-1) 
+//          {
+//            ClassDef *baseClass=getClass(resName.left(i));
+//            if (baseClass)
+//            {
+//              // add base class to this class
+//              cd->insertBaseClass(baseClass,Public,Normal);
+//              // add this class as super class to the base class
+//              baseClass->insertSuperClass(cd,Public,Normal);
+//            }
+//          }
+//        }
+      } // else class is already found
+    }
+    else if (root->name.right(2)!="::")
+    {
+      if (root->name.length()>0 && root->name[0]!='@')
+        warn("Warning: Compound %s\n"
+             "         defined in file %s at line %d\n"
+             "         is not documented\n",
+              root->name.data(),root->fileName.data(),root->startLine);
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    computeClassRelations(e);
+  }
+}
+
+//-----------------------------------------------------------------------
+// compute the references (anchors in HTML) for each member in the class
+
+void computeMemberReferences()
+{
+  ClassDef *cd=classList.first();
+  while (cd)
+  {
+    cd->computeAnchors();
+    cd=classList.next();
+  } 
+}
+
+//-----------------------------------------------------------------------
+// compute the references (anchors in HTML) for each function in the file
+
+void computeFunctionReferences()
+{
+  FileName *fn=inputNameList.first();
+  while (fn)
+  {
+    FileDef *fd=fn->first();
+    while (fd)
+    {
+      fd->computeAnchors();
+      fd=fn->next();
+    }
+    fn=inputNameList.next();
+  }
+  NamespaceDef *nd=namespaceList.first();
+  while (nd)
+  {
+    nd->computeAnchors();
+    nd=namespaceList.next();
+  }
+}
+
+
+
+//----------------------------------------------------------------------
+// Copy the documentation in entry `root' to member definition `md' and
+// set the function declaration of the member to `funcDecl'. If the boolean 
+// over_load is set the standard overload text is added. 
+
+void addMemberDocs(Entry *root,MemberDef *md, const char *funcDecl,
+                        bool over_load)
+{
+  //printf("addMemberDocs: `%s'::`%s' `%s' funcDecl=`%s'\n",
+  //     root->parent->name.data(),md->name().data(),md->argsString(),funcDecl);
+  QString fDecl=funcDecl;
+  // strip extern specifier
+  if (fDecl.left(7)=="extern ") fDecl=fDecl.right(fDecl.length()-7);
+  md->setDefinition(fDecl);
+  ClassDef     *cd=md->memberClass();
+  NamespaceDef *nd=md->getNamespace();
+  if (matchArguments(md->argumentList(),root->argList,
+        cd ? cd->name().data() : 0,
+        nd ? nd->name().data() : 0
+        )
+     ) mergeArguments(md->argumentList(),root->argList);
+  if (over_load)  // the \overload keyword was used
+  {
+    QString doc=getOverloadDocs();
+    if (!root->doc.isNull())
+    {
+      doc+="<p>";
+      doc+=root->doc;
+    }
+    md->setDocumentation(doc); 
+  }
+  else  
+  {
+    // documentation outside a compound overrides the documentation inside it
+    if ( /* !md->isStatic() && !root->stat &&   do not replace doc of a static */
+        (
+         !md->documentation() ||             /* no docs yet */
+         (root->parent->name.isNull() &&     /* or overwrite prototype docs */
+          !root->proto && md->isPrototype()  /* with member definition docs */
+         )
+        ) && root->doc.length()>0 
+       )
+    {
+      md->setDocumentation(root->doc);
+    }
+
+    // brief descriptions inside a compound override the documentation 
+    // outside it
+    if ( /* !md->isStatic() && !root->stat &&  do not replace doc of static */
+        ( 
+         !md->briefDescription() ||        /* no docs yet */
+         !root->parent->name.isNull()      /* member of a class */
+        ) && root->brief.length()>0
+       )
+    {
+      md->setBriefDescription(root->brief);
+    }
+  }
+  md->setDefFile(root->fileName);
+  md->setDefLine(root->startLine);
+  if (cd) cd->insertUsedFile(root->fileName);
+}
+
+//----------------------------------------------------------------------
+// Adds the documentation contained in `root' to a global function
+// with name `name' and argument list `args' (for overloading) and
+// function declaration `decl' to the corresponding member definition.
+
+bool findUnrelatedFunction(Entry *root, 
+                           const QString &namespaceName,
+                           const char *name, 
+                           const char *, 
+                           const char *decl)
+{
+  MemberName *mn=0;
+  QString n=name;
+  if (n.find("::")!=-1) return FALSE; // skip undefined class members
+  //printf("findUnrelatedFunction(%s)\n",name);
+  if (n.length()>0 && (mn=functionNameDict[n])) // function name defined
+  {
+    int count=0;
+    MemberDef *md=mn->first();
+    while (md)
+    {
+      NamespaceDef *nd=md->getNamespace();
+      QString nsName = nd ? nd->name().data() : "";
+      if (namespaceName.length()==0 || 
+          nsName==namespaceName)
+      {
+        //printf("Searching for match between %s and %s\n",
+        //    argListToString(md->argumentList()).data(),
+        //    argListToString(root->argList).data());
+        bool matching=
+          /*matchArguments(md->argsString(),args);*/
+          (md->argumentList()==0 && root->argList->count()==0) ||
+          matchArguments(md->argumentList(),root->argList,0,nsName);
+        if (matching) // add docs to the member
+        {
+          //printf("Match found\n");
+          addMemberDocs(root,md,decl,FALSE);
+          count++;
+        }
+      }
+      md=mn->next();
+    } 
+    if (count==0) // more than one match (each member will get the same docs)!
+    {
+      warn("Warning: no matching members found for \n%s\n"
+           "in file %s at line %d\n",
+           decl,root->fileName.data(),root->startLine);   
+    }
+#if 0
+    else if (count>1) // no match!
+    {
+      warn("Warning: multiple matching members for\n%s\n",decl);
+      if (mn->count()>0) // there is a member with that name
+      {
+        warn("Possible candidates are:\n");
+        MemberDef *md=mn->first();
+        while (md) // list all possible members with the same name
+        {
+          warn("  %s%s\n",md->name(),md->argsString());
+          md=mn->next();
+        }
+      }
+    }
+#endif
+  }
+  else // got docs for an undefined member!
+  {
+    warn("Warning: documented function `%s' in file %s at line %d "
+         "was not defined \n",decl,
+         root->fileName.data(),root->startLine);
+  }
+  return TRUE;
+}
+
+
+//----------------------------------------------------------------------
+// This function tries to find a member (in a documented class/file/namespace) 
+// that corresponds to the function declaration given in `funcDecl'.
+//
+// The related field may be used to specify a related class name.
+// It is only used if the class name cannot be extracted from the function
+// declaration.
+//
+// The boolean overloaded is used to specify whether or not a standard
+// overload documentation line should be generated.
+
+void findMember(Entry *root,QString funcDecl,QString related,bool overloaded,
+                bool isFunc)
+{
+  Debug::print(Debug::FindMembers,0,
+               "findMember(root=%p,funcDecl=`%s',related=`%s',overload=%d,isFunc=%d)\n",
+               root,funcDecl.data(),related.data(),overloaded,isFunc
+              );
+
+  QString scopeName;
+  QString className;
+  QString namespaceName;
+  QString classTempList;
+  QString funcType;
+  QString funcName;
+  QString funcArgs;
+  QString funcTempList;
+  QString exceptions;
+  bool isRelated=FALSE;
+  bool isFriend=FALSE;
+  
+  if (funcDecl.left(7)=="friend ") // treat friends as related members
+  {
+    funcDecl=funcDecl.right(funcDecl.length()-7);
+    isFriend=TRUE;
+  }
+  
+  // delete any ; from the function declaration
+  int sep;
+  while ((sep=funcDecl.find(';'))!=-1)
+  {
+    funcDecl=(funcDecl.left(sep)+funcDecl.right(funcDecl.length()-sep-1)).stripWhiteSpace();
+  }
+  
+  // make sure the first character is a space to simplify searching.
+  if (funcDecl.length()>0 && funcDecl[0]!=' ') funcDecl.prepend(" ");
+  
+  // remove some superfluous spaces
+  funcDecl=substitute(
+             substitute(
+               substitute(funcDecl,"~ ","~"),
+               ":: ","::"
+             ),
+             " ::","::"
+           );
+  
+  // extract information from the declarations
+  parseFuncDecl(funcDecl,scopeName,classTempList,funcType,funcName,
+                funcArgs,funcTempList,exceptions
+               );
+  
+  // the class name can also be a namespace name, we decide this later.
+  // if a related class name is specified and the class name could
+  // not be derived from the function declaration, then use the
+  // related field.
+  //printf("scopeName=`%s' className=`%s'\n",scopeName.data(),className.data());
+  if (/*scopeName.isEmpty() &&*/ !related.isEmpty() && !isRelated)
+  {
+    isRelated=TRUE;
+    //scopeName=resolveDefines(related);
+    if (!scopeName.isEmpty() && scopeName!=related)
+      scopeName+="::"+related;
+    else 
+      scopeName=related.copy();
+  }
+  else if (scopeName.isEmpty() && related.isEmpty() && root->parent && 
+           !root->parent->name.isNull())
+  {
+    Entry *p=root->parent;
+    while (p) // get full scope as class name
+    {
+      if (((p->section & Entry::COMPOUND_MASK) || 
+           p->section == Entry::NAMESPACE_SEC
+          ) && !p->name.isEmpty() && p->name[0]!='@'
+         )
+      {
+        if (!scopeName.isEmpty()) scopeName.prepend("::");
+        scopeName.prepend(p->name);
+        break; // stop here because the class name already contains
+               // the whole scope!
+      }
+      p=p->parent;
+    } 
+  }
+
+  if (scopeName.length()>0 && scopeName.find('<')==-1 && classTempList.length()==0 )
+  { // class is a template, but no template name list found
+    ClassDef *cd=getClass(scopeName); 
+    if (cd) // class exists
+    {
+      classTempList = cd->getTemplateNameString();
+    }
+  }
+  
+  //printf("scopeName=`%s' className=`%s'\n",scopeName.data(),className.data());
+  // rebuild the function declaration (needed to get the scope right).
+  if (scopeName.length()>0 && !isRelated && !isFriend)
+  {
+    if (funcType.length()>0)
+    {
+      if (isFunc) // a function -> we use argList for the arguments
+      {
+        funcDecl=funcType+" "+scopeName+classTempList+"::"+funcName+funcTempList;
+      }
+      else
+      {
+        funcDecl=funcType+" "+scopeName+classTempList+"::"+funcName+funcArgs;
+      }
+    }
+    else
+    {
+      if (isFunc) // a function => we use argList for the arguments
+      {
+        funcDecl=scopeName+classTempList+"::"+funcName+funcTempList;
+      }
+      else // variable => add `argument' list
+      {
+        funcDecl=scopeName+classTempList+"::"+funcName+funcArgs;
+      }
+    }
+  }
+  else // build declaration without scope
+  {
+    if (funcType.length()>0) // but with a type
+    {
+      if (isFunc) // function => omit argument list
+      {
+        funcDecl=funcType+" "+funcName+funcTempList;
+      }
+      else // variable => add `argument' list
+      {
+        funcDecl=funcType+" "+funcName+funcArgs;
+      }
+    }
+    else // no type
+    {
+      if (isFunc)
+      {
+        funcDecl=funcName+funcTempList;
+      }
+      else
+      {
+        funcDecl=funcName+funcArgs;
+      }
+    }
+  }
+  
+  QString fullFuncDecl=funcDecl.copy();
+  if (isFunc) fullFuncDecl+=argListToString(root->argList);
+  
+  //printf("scopeName=`%s' className=`%s'\n",scopeName.data(),className.data());
+  // see if (part of) the scope name is a namespace name
+  extractNamespaceName(scopeName,className,namespaceName);
+  //printf("scopeName=`%s' className=`%s'\n",scopeName.data(),className.data());
+
+  // destructor => do backward class name substitution if needed
+  //if (funcName.length()>0 && funcName[0]=='~') 
+  //  funcName="~"+resolveDefines(className);
+  // constructor => do backward class name substitution if needed
+  //if (funcName==className) funcName=resolveDefines(className);
+  //if (funcDecl.left(7)=="inline ") funcDecl=funcDecl.right(funcDecl.length()-7);
+  
+  Debug::print(Debug::FindMembers,0,
+           "findMember() Parse results:\n"
+           "  namespaceName=`%s'\n"
+           "  className=`%s`\n"
+           "  classTempList=`%s'\n"
+           "  funcType=`%s'\n"
+           "  funcName=`%s'\n"
+           "  funcArgs=`%s'\n"
+           "  funcTempList=`%s'\n"
+           "  funcDecl=`%s'\n"
+           "  related=`%s'\n" 
+           "  exceptions=`%s'\n"
+           "  isRelated=%d\n"
+           "  isFiend=%d\n"
+           "  isFunc=%d\n\n",
+           namespaceName.data(),className.data(),classTempList.data(),
+           funcType.data(),funcName.data(),funcArgs.data(),funcTempList.data(),
+           funcDecl.data(),related.data(),exceptions.data(),isRelated,isFriend,
+           isFunc
+          );
+
+  MemberName *mn;
+  if (funcName.length()>0) // function name is valid
+  { 
+    if (!isRelated && (mn=memberNameDict[funcName])) // function name already found
+    {
+      if (className.length()>0) // class name is valid
+      {
+        int count=0;
+        MemberDef *md=mn->first();
+        while (md)
+        {
+          ClassDef *cd=md->memberClass();
+          //printf("Member %s member className=%s this className=%s\n",md->name().data(),cd->name().data(),className.data());
+          ClassDef *tcd=0;
+          if (classTempList.length()>0) // try to find the correct specialization
+          {
+            tcd=getClass(scopeName+classTempList);
+            if (!tcd) tcd=getClass(scopeName); // try general class
+          }
+          else
+          {
+            tcd=getClass(scopeName);
+          }
+          //printf("tcd=%p\n",tcd);
+          if (cd && tcd==cd)
+          {
+            //printf("Class %s\n",cd->name().data());
+            bool matching=
+              md->isVariable() || md->isTypedef() || // needed for function pointers
+              (md->argumentList()==0 && root->argList->count()==0) || 
+              matchArguments(md->argumentList(), root->argList,
+                  className,namespaceName);
+            if (matching) 
+            {
+              addMemberDocs(root,md,funcDecl,overloaded);
+              count++;
+            }
+          } 
+          md=mn->next();
+        } 
+        if (count==0) 
+          warn("Warning: no matching member found for \n%s\n"
+                 "in file %s at line %d\n",
+                 fullFuncDecl.data(),root->fileName.data(),root->startLine);   
+#if 0
+        else if (count>1)
+        {
+          warn("Warning: multiple matching members for\n%s\n",funcDecl.data());
+          int matchCount=0;
+          MemberDef *md=mn->first(); 
+          while (md)
+          {
+            if (md->memberClass() && className==md->memberClass()->name()) 
+              matchCount++;
+            md=mn->next();
+          } 
+          if (matchCount>0)
+          {
+            warn("Possible candidates are:\n");
+            md=mn->first();
+            while (md)
+            {
+              ClassDef *cd=md->memberClass();
+              if (cd && className==cd->name())
+                warn("  %s::%s%s\n",md->memberClass()->name(),
+                    md->name(),md->argsString());
+              md=mn->next();
+            }
+          }
+        }
+#endif
+      }
+      else if (overloaded) // check if the function belongs to only one class 
+      {
+        // for unique overloaded member we allow the class to be
+        // omitted, this is to be Qt compatable. Using this should 
+        // however be avoided, because it is error prone
+        MemberDef *md=mn->first();
+        ASSERT(md);
+        ClassDef *cd=md->memberClass();
+        ASSERT(cd);
+        QString className=cd->name().copy();
+        md=mn->next();
+        bool unique=TRUE;
+        while (md)
+        {
+          ClassDef *cd=md->memberClass();
+          if (className!=cd->name()) unique=FALSE; 
+          md=mn->next();
+        } 
+        if (unique)
+        {
+          MemberDef::MemberType mtype;
+          if      (root->sig)  mtype=MemberDef::Signal;
+          else if (root->slot) mtype=MemberDef::Slot;
+          else                 mtype=MemberDef::Function;
+          
+          // new overloaded member function
+          MemberDef *md=new MemberDef(funcType,funcName,funcArgs,exceptions,
+                            root->protection,root->virt,root->stat,TRUE,
+                            mtype,root->tArgList,root->argList);
+          md->setMemberClass(cd);
+          md->setDefinition(funcDecl);
+          QString doc=getOverloadDocs();
+          doc+="<p>";
+          doc+=root->doc;
+          md->setDocumentation(doc);
+          //md->setDecFile(root->fileName);
+          //md->setDecLine(root->startLine);
+          md->setDefFile(root->fileName);
+          md->setDefLine(root->startLine);
+          md->setPrototype(root->proto);
+          mn->inSort(md);
+          cd->insertMember(md);
+          cd->insertUsedFile(root->fileName);
+        }
+      }
+      else // unrelated function with the same name as a member
+      {
+        if (!findUnrelatedFunction(root,namespaceName,funcName+funcTempList,funcArgs,funcDecl))
+        {
+          warn("Warning: Cannot determine class for function\n%s\n"
+               "in file %s at line %d\n",fullFuncDecl.data(),
+               root->fileName.data(),root->startLine);   
+        }
+      }
+    }
+    else if (isRelated && related.length()>0)
+    {
+      if (className.isEmpty()) className=related.copy();
+      ClassDef *cd;
+      if ((cd=getClass(scopeName)))
+      {
+        bool newMember=TRUE; // assume we have a new member
+        bool newMemberName=FALSE; 
+        if ((mn=memberNameDict[funcName])==0)
+        {
+          mn=new MemberName(funcName);
+          newMemberName=TRUE; // we create a new member name
+        }
+        else
+        {
+          MemberDef *rmd=mn->first();
+          while (rmd && newMember) // see if we got another member with matching arguments
+          {
+            newMember=newMember && 
+              !matchArguments(rmd->argumentList(),root->argList,className,namespaceName);
+            if (newMember) rmd=mn->next();
+          }
+          if (!newMember && rmd) // member already exists as rmd -> add docs
+          {
+            addMemberDocs(root,rmd,funcDecl,overloaded);
+          }
+        }
+        if (newMember) // need to create a new member
+        {
+          MemberDef::MemberType mtype;
+          if (root->sig)  
+            mtype=MemberDef::Signal;
+          else if (root->slot) 
+            mtype=MemberDef::Slot;
+          else                 
+            mtype=MemberDef::Function;
+
+          // new related (member) function
+          MemberDef *md=new MemberDef(funcType,funcName,funcArgs,exceptions,
+              root->protection,root->virt,root->stat,TRUE,
+              mtype,root->tArgList,root->argList);
+          //printf("Related member name=`%s' decl=`%s'\n",funcName.data(),funcDecl.data());
+          md->setMemberClass(cd);
+          md->setDefinition(funcDecl);
+          md->setDocumentation(root->doc);
+          md->setBriefDescription(root->brief);
+          md->setDefFile(root->fileName);
+          md->setDefLine(root->startLine);
+          md->setPrototype(root->proto);
+          mn->inSort(md);
+          cd->insertMember(md);
+          cd->insertUsedFile(root->fileName);
+          if (newMemberName)
+          {
+            //printf("Adding memberName=%s\n",mn->memberName());
+            memberNameList.inSort(mn);
+            memberNameDict.insert(funcName,mn);
+          }
+        }
+      }
+      else
+      {
+        warn("Warning: class `%s' for related function `%s' is not "
+            "documented\n", className.data(),funcName.data());
+      }
+    }
+    else // unrelated not overloaded member found
+    {
+      if (className.length()==0 && 
+          !findUnrelatedFunction(root,namespaceName,funcName+funcTempList,funcArgs,funcDecl))
+      {
+        warn("Warning: class for member %s (file %s at line %d) cannot "
+             "be found\n", funcName.data(),root->fileName.data(),
+             root->startLine); 
+      }
+    }
+  }
+  else
+  {
+    // this should not be called
+    warn("Warning: member with no name found in %s at line %d\n",
+              root->fileName.data(),root->startLine);
+  }
+  return;
+} 
+
+//----------------------------------------------------------------------
+// find the members corresponding to the different documentation blocks
+// that are extracted from the sources.
+
+void findMemberDocumentation(Entry *root)
+{
+  int i,l;
+  QRegExp re("([a-zA-Z0-9: ]*[ *]+[ ]*");
+  Debug::print(Debug::FindMembers,0,
+         "root->type=`%s' root->name=`%s' root->args=`%s'\n",
+          root->type.data(),root->name.data(),root->args.data()
+         );
+  bool isFunc=TRUE;
+  if ((i=re.match(root->type,0,&l))!=-1) // func variable/typedef to func ptr
+  {
+    root->args+=root->type.right(root->type.length()-i-l);
+    root->type=root->type.left(i+l);
+    isFunc=FALSE;
+  }
+  else if (root->name.find(re)!=-1 && root->name.find("operator")!=-1) 
+    // func ptr entered with \fn, \var or \typedef
+  {
+    isFunc=FALSE;
+  }
+  else if ((root->type.isEmpty() && root->name.left(8)=="typedef ")
+           || root->args.find('(')==-1)
+  {
+    isFunc=FALSE;
+  }
+  //printf("Member %s isFunc=%d\n",root->name.data(),isFunc);
+  if (root->section==Entry::MEMBERDOC_SEC)
+  {
+    //printf("Documentation for inline member `%s' found args=`%s'\n",
+    //    root->name.data(),root->args.data());
+    //if (root->relates.length()) printf("  Relates %s\n",root->relates.data());
+    findMember(root,root->name+root->args+root->exception,root->relates,FALSE,isFunc);
+  }
+  else if (root->section==Entry::OVERLOADDOC_SEC) 
+  {
+    //printf("Overloaded member %s found\n",root->name.data());
+    findMember(root,root->name,root->relates,TRUE,isFunc);
+  }
+  else if (root->section==Entry::FUNCTION_SEC && 
+      (root->doc.length()>0 || root->brief.length()>0 || extractAllFlag))
+  {
+    //printf("Documentation for member `%s' found args=`%s' excp=`%s'\n",
+    //    root->name.data(),root->args.data(),root->exception.data());
+    //if (root->relates.length()) printf("  Relates %s\n",root->relates.data());
+    //printf("Inside=%s\n Relates=%s\n",root->inside.data(),root->relates.data());
+    if (root->type.length()>0)
+    {
+      findMember(root,
+          root->type+" "+root->inside+root->name+root->args+root->exception,
+          root->relates,
+          FALSE,isFunc);
+    }
+    else
+    {
+      findMember(root,
+          root->inside+root->name+root->args+root->exception,
+          root->relates,
+          FALSE,isFunc);
+    }
+  }
+  else if (root->section==Entry::VARIABLEDOC_SEC)
+  {
+    //printf("Documentation for variable %s found\n",root->name.data());
+    //if (root->relates.length()>0) printf("  Relates %s\n",root->relates.data());
+    findMember(root,root->name,root->relates,FALSE,FALSE);
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    if (e->section!=Entry::ENUM_SEC) findMemberDocumentation(e);
+  }
+}
+
+//----------------------------------------------------------------------
+// find and add the enumeration to their classes, namespaces or files
+
+void findEnums(Entry *root)
+{
+  if (root->section==Entry::ENUM_SEC)
+    // non anonymous enumeration
+  {
+    MemberDef    *md=0;
+    ClassDef     *cd=0;
+    FileDef      *fd=0;
+    NamespaceDef *nd=0;
+    MemberNameDict *mnd=0;
+    MemberNameList *mnl=0;
+    bool isGlobal;
+    //printf("Found enum with name `%s'\n",root->name.data());
+    int i;
+
+    QString name;
+    if ((i=root->name.findRev("::"))!=-1) // scope is specified
+    {
+      QString scope=root->name.left(i); // extract scope
+      name=root->name.right(root->name.length()-i-2); // extract name
+      cd=getClass(scope);
+      if (!cd) nd=namespaceDict[scope];
+    }
+    else // no scope, check the scope in which the docs where found
+    {
+      if (( root->parent->section & Entry::COMPOUND_MASK )
+          && root->parent->name.length()>0
+         ) // found enum docs inside a compound
+      {
+        cd=getClass(root->parent->name);
+      }
+      name=root->name.copy();
+    }
+    if (cd && name.length()>0) // found a enum inside a compound
+    {
+      //printf("Enum `%s'::`%s'\n",cd->name(),name.data());
+      fd=0;
+      mnd=&memberNameDict;
+      mnl=&memberNameList;
+      isGlobal=FALSE;
+    }
+    else if (nd) // found enum inside namespace
+    {
+      mnd=&functionNameDict;
+      mnl=&functionNameList;
+      isGlobal=TRUE;
+    }
+    else // found a global enum
+    {
+      bool ambig;
+      fd=findFileDef(&inputNameDict,root->fileName,ambig);
+      mnd=&functionNameDict;
+      mnl=&functionNameList;
+      isGlobal=TRUE;
+    }
+    if (name.length()>0)
+    {
+      // new enum type
+      md = new MemberDef(0,name,0,0,root->protection,Normal,FALSE,FALSE,
+               MemberDef::Enumeration,0,0);
+      if (!isGlobal) md->setMemberClass(cd); else md->setFileDef(fd);
+      md->setDefFile(root->fileName);
+      md->setDefLine(root->startLine);
+      if (nd)
+      {
+        md->setDefinition(nd->name()+"::"+name);  
+        nd->insertMember(md);
+        md->setNamespace(nd);
+      }
+      else if (isGlobal)
+      {
+        md->setDefinition(name);
+        fd->insertMember(md);
+      }
+      else if (cd)
+      {
+        md->setDefinition(cd->name()+"::"+name);
+        cd->insertMember(md);
+        cd->insertUsedFile(root->fileName);
+      }
+      md->setDocumentation(root->doc);
+      md->setBriefDescription(root->brief);
+
+      MemberName *mn;
+      if ((mn=(*mnd)[name]))
+      {
+        // this is used if the same enum is in multiple namespaces/classes
+        mn->inSort(md);
+      }
+      else // new enum name
+      {
+        mn = new MemberName(name);
+        mn->inSort(md);
+        mnd->insert(name,mn);
+        mnl->inSort(mn);
+        //printf("add %s to new memberName. Now %d members\n",
+        //       name.data(),mn->count());
+      }
+
+      EntryListIterator eli(*root->sublist);
+      Entry *e;
+      for (;(e=eli.current());++eli)
+      {
+        MemberName *fmn=0;
+        if (e->name.length()>0 && (fmn=(*mnd)[e->name])) 
+           // get list of members with the same name as the field
+        {
+          MemberDef *fmd=fmn->first();
+          while (fmd) // search for the class with the right name
+          {
+            if (nd)
+            {
+              NamespaceDef *fnd=fmd->getNamespace();
+              if (fnd==nd)
+              {
+                md->insertEnumField(fmd);
+                fmd->setEnumScope(md);
+              }
+            }
+            else if (isGlobal)
+            {
+              FileDef *ffd=fmd->getFileDef();
+              if (ffd==fd)
+              {
+                md->insertEnumField(fmd);
+                fmd->setEnumScope(md);
+              }
+            }
+            else
+            {
+              ClassDef *fcd=fmd->memberClass();
+              if (fcd==cd)
+              {
+                md->insertEnumField(fmd); // add field def to list
+                fmd->setEnumScope(md);    // cross ref with enum name
+              }
+            }
+            fmd=fmn->next();
+          } 
+        }
+      }
+    }
+  }
+  else
+  {
+    EntryListIterator eli(*root->sublist);
+    Entry *e;
+    for (;(e=eli.current());++eli)
+    {
+      findEnums(e);
+    }
+  }
+}
+
+//----------------------------------------------------------------------
+// find the documentation blocks for the enumerations
+
+void findEnumDocumentation(Entry *root)
+{
+  if (root->section==Entry::ENUMDOC_SEC
+      && root->name.length()>0
+      && root->name[0]!='@'        // skip anonymous enums
+     )
+  {
+    //printf("Found docs for enum with name `%s'\n",root->name.data());
+    int i;
+    ClassDef *cd=0;
+    QString name;
+    if ((i=root->name.findRev("::"))!=-1) // scope is specified
+    {
+      QString scope=root->name.left(i); // extract scope
+      name=root->name.right(root->name.length()-i-2); // extract name
+      cd=getClass(scope);
+      //printf("Scope=`%s' Name=`%s'\n",scope.data(),name.data());
+    }
+    else // no scope, check the scope in which the docs where found
+    {
+      if (( root->parent->section & Entry::COMPOUND_MASK )
+          && root->parent->name.length()>0
+         ) // found enum docs inside a compound
+      {
+        cd=getClass(root->parent->name);
+      }
+      name=root->name.copy();
+    }
+    if (name.length()>0)
+    {
+      bool found=FALSE;
+      if (cd)
+      {
+        //printf("Enum: scope=`%s' name=`%s'\n",cd->name(),name.data());
+        QString className=cd->name().copy();
+        MemberName *mn=memberNameDict[name];
+        if (mn)
+        {
+          MemberDef  *md=mn->first();
+          while (md && !found)
+          {
+            ClassDef *cd=md->memberClass();
+            if (cd && cd->name()==className)
+            {
+              // documentation outside a compound overrides the documentation inside it
+              if (!md->documentation() || root->parent->name.length()==0) 
+              {
+                md->setDocumentation(root->doc);
+              }
+
+              // brief descriptions inside a compound override the documentation 
+              // outside it
+              if (!md->briefDescription() || root->parent->name.length()>0)
+              {
+                md->setBriefDescription(root->brief);
+              }
+              found=TRUE;
+            }
+            md=mn->next();
+          }
+        }
+        else
+        {
+          //printf("MemberName %s not found!\n",name.data());
+        }
+      }
+      else // enum outside class 
+      {
+        MemberDef  *md;
+        MemberName *mn=functionNameDict[name];
+        if (mn && (md=mn->first()))
+        {
+          md->setDocumentation(root->doc);
+          md->setBriefDescription(root->brief);
+          found=TRUE;
+        }
+      } 
+      if (!found)
+      {
+        warn("Warning: Documentation for undefined enum `%s' found at"
+             " line %d of file %s\n",name.data(),
+               root->startLine,root->fileName.data());
+      }
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    findEnumDocumentation(e);
+  }
+}
+
+//----------------------------------------------------------------------
+// recursive function:
+// returns TRUE iff class definition `bcd' represents an (in)direct base 
+// class of class definition `cd'.
+
+bool isBaseClass(ClassDef *bcd,ClassDef *cd)
+{
+  bool found=FALSE;
+  //printf("isBaseClass(cd=%s) looking for %s\n",cd->name().data(),bcd->name().data());
+  BaseClassListIterator bcli(*cd->baseClasses());
+  for ( ; bcli.current() && !found ; ++bcli)
+  {
+    ClassDef *ccd=bcli.current()->classDef;
+    //printf("isBaseClass() baseclass %s\n",ccd->name().data());
+    if (ccd==bcd) 
+      found=TRUE;
+    else 
+      found=isBaseClass(bcd,ccd);
+  }
+  return found;
+}
+
+//----------------------------------------------------------------------
+// computes the relation between all members. For each member `m'
+// the members that override the implementation of `m' are searched and
+// the member that `m' overrides is searched.
+
+void computeMemberRelations()
+{
+  MemberName *mn=memberNameList.first();
+  while (mn) // for each member name
+  {
+    MemberNameIterator mdi(*mn);
+    for ( ; mdi.current() ; ++mdi) // for each function with a specific name
+    {
+      MemberDef *md=mdi.current();
+      MemberNameIterator bmdi(*mn);
+      for ( ; bmdi.current() ; ++bmdi) // for each other function with that name
+      {
+        MemberDef *bmd=bmdi.current();
+        if (md!=bmd && bmd->memberClass() && md->memberClass() &&
+            isBaseClass(bmd->memberClass(),md->memberClass()))
+        {
+          //printf("Checking Base: %s\nWith normal  : %s\n",bmd->definition(),md->definition());
+          if (/*matchArguments(bmd->argsString(),md->argsString())*/
+              matchArguments(bmd->argumentList(),md->argumentList())
+             )
+          {
+            //printf("Base: %s\nNorm: %s\n",bmd->definition(),md->definition());
+            ClassDef *bmcd = bmd->memberClass();
+            ClassDef *mcd = md->memberClass();
+            if (mcd && bmcd && 
+                (bmcd->protection()!=Private || extractPrivateFlag) &&
+                (bmcd->hasDocumentation() || !hideClassFlag) &&
+                (mcd->protection()!=Private || extractPrivateFlag) &&
+                (mcd->hasDocumentation() || !hideClassFlag)
+               )
+            {
+              md->setReimplements(bmd);
+              bmd->insertReimplementedBy(md);
+            }
+          }  
+        }
+      }
+    }
+    mn=memberNameList.next();
+  }  
+}
+
+//----------------------------------------------------------------------------
+// recusively merges the `all members' lists of class cd's base classes
+// with that of class `cd' itself.
+
+void mergeMembers(ClassDef *cd,BaseClassList *bcl)
+{
+  //if (mcd->flag==TRUE)
+  //{
+  //  err("Error: Cyclic inhertance dependency found for class %s\n",mcd->name());
+  //  return;
+  //}
+  //mcd->flag=TRUE;
+
+  BaseClassListIterator bcli(*bcl);
+  BaseClassDef *bcd;
+  for ( ; (bcd=bcli.current()) ; ++bcli )
+  {
+    ClassDef *bClass=bcd->classDef; 
+    // merge the members of bClass with the onces from cd
+    
+    mergeMembers(bClass,bClass->baseClasses());
+    // the all member list of the branch until bClass is now complete
+    // so we can merge it with cd
+    
+    MemberNameInfoList *srcMnl  = bClass->memberNameInfoList();
+    MemberNameInfoDict *dstMnd  =     cd->memberNameInfoDict();
+    MemberNameInfoList *dstMnl  =     cd->memberNameInfoList();
+    
+    MemberNameInfoListIterator srcMnili(*srcMnl);
+    MemberNameInfo *srcMni;
+    for ( ; (srcMni=srcMnili.current()) ; ++srcMnili)
+    {
+      //printf("Base member name %s\n",srcMni->memberName());
+      MemberNameInfo *dstMni;
+      if ((dstMni=dstMnd->find(srcMni->memberName())))
+        // a member with that name is already in the class.
+        // the member may hide or reimplement the one in the super class
+        // or there may be another path to the base class that is already 
+        // visited via another branch in the class hierarchy.
+      {
+        MemberNameInfoIterator srcMnii(*srcMni); 
+        MemberInfo *srcMi;
+        for ( ; (srcMi=srcMnii.current()) ; ++srcMnii )
+        {
+          MemberDef *srcMd = srcMi->memberDef;
+          bool found=FALSE;
+          bool ambigue=FALSE;
+          MemberNameInfoIterator dstMnii(*dstMni); 
+          MemberInfo *dstMi;
+          for ( ; (dstMi=dstMnii.current()) && !found; ++dstMnii )
+          {
+            MemberDef *dstMd = dstMi->memberDef;
+            if (srcMd!=dstMd) // different members
+            {
+              ClassDef *srcCd = srcMd->memberClass();
+              ClassDef *dstCd = dstMd->memberClass();
+              //printf("Is %s a base class of %s?\n",srcCd->name(),dstCd->name());
+              if (srcCd==dstCd || isBaseClass(srcCd,dstCd)) 
+                // member is in the same or a base class
+              {
+                found = 
+                  /*matchArguments(srcMd->argsString(),dstMd->argsString());*/
+                  matchArguments(srcMd->argumentList(),dstMd->argumentList());
+              }
+              else // member is in a non base class => multiple inheritance
+                   // using the same base class.
+              {
+                //printf("$$ Existing member %s %s add scope %s\n",
+                //    dstMi->ambiguityResolutionScope.data(),
+                //    dstMd->name().data(),
+                //    dstMi->scopePath.left(dstMi->scopePath.find("::")+2).data());
+                         
+                QString scope=dstMi->scopePath.left(dstMi->scopePath.find("::")+2);
+                if (scope!=dstMi->ambiguityResolutionScope.left(scope.length()))
+                  dstMi->ambiguityResolutionScope.prepend(scope);
+                ambigue=TRUE;
+              }
+            }
+            else // same members
+            {
+              // do not add if base class is virtual or 
+              // if scope paths are equal
+              if ((srcMi->virt==Virtual && dstMi->virt==Virtual) ||
+                  bClass->name()+"::"+srcMi->scopePath == dstMi->scopePath
+                 ) found=TRUE;
+              else // member can be reached via multiple paths in the 
+                   // inheritance tree
+              {
+                //printf("$$ Existing member %s %s add scope %s\n",
+                //    dstMi->ambiguityResolutionScope.data(),
+                //    dstMd->name().data(),
+                //    dstMi->scopePath.left(dstMi->scopePath.find("::")+2).data());
+
+                QString scope=dstMi->scopePath.left(dstMi->scopePath.find("::")+2);
+                if (scope!=dstMi->ambiguityResolutionScope.left(scope.length()))
+                  dstMi->ambiguityResolutionScope.prepend(scope);
+                ambigue=TRUE;
+              }
+            }
+          }
+          if (!found && srcMd->protection()!=Private)
+          {
+            Specifier virt=srcMi->virt;
+            if (srcMi->virt==Normal && bcd->virt!=Normal) virt=bcd->virt;
+            MemberInfo *newMi = new MemberInfo(srcMd,bcd->prot,virt);
+            //if (srcMi->memberDef->memberClass()!=bClass)
+            newMi->scopePath=bClass->name()+"::"+srcMi->scopePath;
+            if (ambigue)
+            {
+              //printf("$$ New member %s %s add scope %s::\n",
+              //     srcMi->ambiguityResolutionScope.data(),
+              //     srcMd->name().data(),
+              //     bClass->name().data());
+
+              QString scope=bClass->name().copy(); scope+="::";
+              if (scope!=srcMi->ambiguityResolutionScope.left(scope.length()))
+                newMi->ambiguityResolutionScope=
+                  scope+srcMi->ambiguityResolutionScope;
+            }
+            dstMni->append(newMi);
+          }
+        }
+      }
+      else // base class has a member that is not in the super class => copy
+      {
+        // create a deep copy of the list (only the MemberInfo's will be 
+        // copied, not the actual MemberDef's)
+        MemberNameInfo *newMni = new MemberNameInfo(srcMni->memberName()); 
+        
+        // copy the member(s) from the base to the super class
+        MemberNameInfoIterator mnii(*srcMni);
+        MemberInfo *mi;
+        for (;(mi=mnii.current());++mnii)
+        {
+          if (mi->memberDef->protection()!=Private)
+          {
+            Specifier virt=mi->virt;
+            if (mi->virt==Normal && bcd->virt!=Normal) virt=bcd->virt;
+            MemberInfo *newMi=new MemberInfo(mi->memberDef,bcd->prot,virt);
+            //if (mi->memberDef->memberClass()!=bClass)
+            newMi->scopePath=bClass->name()+"::"+mi->scopePath;
+            newMi->ambiguityResolutionScope=mi->ambiguityResolutionScope.copy();
+            newMni->append(newMi);
+          }
+        }
+        
+        // add it to the list and dictionary
+        dstMnl->inSort(newMni);
+        dstMnd->insert(newMni->memberName(),newMni);
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+// builds the list of all members for each class
+
+void buildCompleteMemberLists()
+{
+  ClassDef *cd;
+  ClassListIterator cli(classList);
+  for (;(cd=cli.current());++cli)
+  {
+    //if (!cd->isReference()) printf("Building member for class %s\n",cd->name());
+    //ClassListIterator vcli(classList);
+    //for (;(vcd=vcli.current());++vcli) vcd->flag = FALSE;
+    if (!cd->isReference() && // not an external class
+         cd->superClasses()->count()==0 && // is a root of the hierarchy
+         cd->baseClasses()->count()>0) // and has at least one base class
+    {
+      //printf("merging members for class %s\n",cd->name());
+      mergeMembers(cd,cd->baseClasses());
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+
+void generateFileDocs()
+{
+  if (documentedFiles==0) return;
+  writeFileIndex(*outputList);
+  
+  if (inputNameList.count()>0)
+  {
+    FileName *fn=inputNameList.first();
+    while (fn)
+    {
+      FileDef *fd=fn->first();
+      while (fd)
+      {
+        if (!fd->isReference() && fd->hasDocumentation())
+        {
+          msg("Generating docs for file %s...\n",fd->name().data());
+          fd->writeDocumentation(*outputList);
+        }
+        fd=fn->next();
+      }
+      fn=inputNameList.next();
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate the documentation of all classes
+  
+void generateClassDocs()
+{
+  // write the installdox script if necessary
+  if (generateHtml && (tagFileList.count()>0 || searchEngineFlag)) 
+    writeInstallScript();
+  
+  msg("Generating index page...\n"); 
+  writeIndex(*outputList);
+
+  msg("Generating compound index...\n");
+  writeAnnotatedIndex(*outputList);
+
+  msg("Generating hierarchical class index...\n");
+  writeHierarchicalIndex(*outputList);
+
+  if (includeFiles.count()>0)
+  {
+    msg("Generating header index...\n");
+    writeHeaderIndex(*outputList);
+  }
+
+  msg("Generating member index...\n");
+  writeMemberIndex(*outputList);
+
+  if (exampleList.count()>0)
+  {
+    msg("Generating example index...\n");
+  }
+
+  ClassListIterator cli(classList);
+  for ( ; cli.current() ; ++cli )
+  {
+    ClassDef *cd=cli.current();
+    if (!cd->isReference() && 
+        //!cd->name().isEmpty() && 
+        //cd->name().at(0)!='@' && 
+        //(cd->protection()!=Private || extractPrivateFlag) &&
+        //(cd->hasDocumentation() || !hideClassFlag)
+        cd->isVisible()
+       ) 
+         // skip external references and anonymous compounds
+    {
+      msg("Generating docs for compound %s...\n",cd->name().data());
+      
+      cd->writeDocumentation(*outputList);
+      cd->writeMemberList(*outputList);
+      if (verbatimHeaderFlag) cd->writeIncludeFile(*outputList);
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+
+void findDefineDocumentation(Entry *root)
+{
+  if ((root->section==Entry::DEFINEDOC_SEC ||
+       root->section==Entry::DEFINE_SEC) && root->name.length()>0
+     )
+  {
+    //printf("found define `%s' `%s' brief=`%s' doc=`%s'\n",
+    //       root->name.data(),root->args.data(),root->brief.data(),root->doc.data());
+    MemberName *mn=functionNameDict[root->name];
+    if (mn)
+    {
+      int count=0;
+      MemberDef *md=mn->first();
+      while (md)
+      {
+        if (md->memberType()==MemberDef::Define) count++;
+        md=mn->next();
+      }
+      if (count==1)
+      {
+        md=mn->first();
+        while (md)
+        {
+          if (md->memberType()==MemberDef::Define)
+          {
+            if (md->documentation().isEmpty())
+              md->setDocumentation(root->doc);
+            if (md->briefDescription().isEmpty())
+              md->setBriefDescription(root->brief);
+          }
+          md=mn->next();
+        }
+      }
+      else if (count>1 && (root->doc.length()>0 || root->brief.length()>0)) 
+        // multiple defines don't know where to add docs
+      {
+        md=mn->first();
+        while (md)
+        {
+          if (md->memberType()==MemberDef::Define)
+          {
+            FileDef *fd=md->getFileDef();
+            if (fd && fd->absFilePath()==root->fileName) 
+              // doc and define in the same file assume they belong together.
+            {
+              if (md->documentation().isEmpty())
+                md->setDocumentation(root->doc);
+              if (md->briefDescription().isEmpty())
+                md->setBriefDescription(root->brief);
+            }
+          }
+          md=mn->next();
+        }
+        //warn("Warning: define %s found in the following files:\n",root->name.data());
+        //warn("Cannot determine where to add the documentation found "
+        //     "at line %d of file %s. \n",
+        //     root->startLine,root->fileName.data());
+      }
+    }
+    else // define not found
+    {
+      warn("Warning: documentation for unknown define %s found at line %d of "
+           "file %s\n",root->name.data(),root->startLine,root->fileName.data());
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    findDefineDocumentation(e);
+  }
+}
+
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+// create a (sorted) list of separate documentation pages
+
+void buildPageList(Entry *root)
+{
+  if (root->section == Entry::PAGEDOC_SEC)
+  {
+    if (root->name.length()>0)
+    {
+      PageInfo *pi=0;
+      if ((pi=pageDict[root->name]))
+      {
+        //warn("Warning: Page %s was already documented. Ignoring documentation "
+        //     "at line %d of %s\n",root->name.data(),root->startLine,
+        //                          root->fileName.data());
+        
+        // append documentation block to the page.
+        pi->doc+="\n\n"+root->doc;
+      }
+      else
+      {
+        QString baseName=root->name.copy();
+        if (baseName.right(4)==".tex") 
+          baseName=baseName.left(baseName.length()-4);
+        else if (baseName.right(5)==".html")
+          baseName=baseName.left(baseName.length()-5);
+        pi=new PageInfo(baseName, root->doc,
+                        root->args.stripWhiteSpace());
+        pageList.append(pi);
+        pageDict.insert(baseName,pi);
+        if (pi->title.length()>0)
+        {
+          QString pageName;
+          if (caseSensitiveNames)
+            pageName=pi->name.copy();
+          else
+            pageName=pi->name.lower();
+          //outputList->writeTitle(pi->name,pi->title);
+          SectionInfo *si=new SectionInfo(pageName+".html",
+              pi->name,pi->title,FALSE);
+          //printf("Adding section info %s\n",pi->name.data());
+          sectionDict.insert(pi->name,si);
+        }
+      }
+    }
+  }
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildPageList(e);
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate all separate documentation pages
+
+void generatePageDocs()
+{
+  PageInfo *pi=pageList.first();
+  while (pi)
+  {
+    if (!pi->title.isEmpty())
+    {
+      msg("Generating docs for page %s...\n",pi->title.data());
+    }
+    else
+    {
+      msg("Generating docs for page %s...\n",pi->name.data());
+    }
+    outputList->disable(OutputGenerator::Man);
+    QString pageName;
+    if (caseSensitiveNames)
+      pageName=pi->name.copy();
+    else
+      pageName=pi->name.lower();
+    
+    startFile(*outputList,pageName,pi->title);
+    SectionInfo *si=0;
+    if (pi->title.length()>0 && pi->name.length()>0 &&
+        (si=sectionDict[pi->name])!=0)
+    {
+      outputList->writeSection(si->label,si->title,FALSE);
+    }
+    parseDoc(*outputList,0,0,pi->doc);
+    endFile(*outputList);
+    outputList->enable(OutputGenerator::Man);
+    pi=pageList.next();
+  }
+}
+
+//----------------------------------------------------------------------------
+// create a (sorted) list & dictionary of example pages
+
+void buildExampleList(Entry *root)
+{
+  if (root->section == Entry::EXAMPLE_SEC)
+  {
+    if (root->name.length()>0) 
+    {
+      if (exampleDict[root->name])
+      {
+        warn("Warning: Example %s was already documented. Ignoring "
+             "documentation at line %d of %s\n",root->name.data(),
+             root->startLine,root->fileName.data());
+      }
+      else
+      {
+        PageInfo *pi=new PageInfo(root->name,root->doc,root->args);
+        exampleList.inSort(pi);
+        exampleDict.insert(root->name,pi);
+      }
+    }
+  }
+  //EntryList *entryList=root->sublist;
+  //Entry *e = entryList->first();
+  //while (e)
+  //{
+  //  buildExampleList(e);
+  //  e=entryList->next(); 
+  //}
+  EntryListIterator eli(*root->sublist);
+  Entry *e;
+  for (;(e=eli.current());++eli)
+  {
+    buildExampleList(e);
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate the example documentation 
+
+void generateExampleDocs()
+{
+  PageInfo *pi=exampleList.first();
+  while (pi)
+  {
+    msg("Generating docs for example %s...\n",pi->name.data());
+    QString n=convertSlashes(pi->name,TRUE)+"-example";
+    startFile(*outputList,n,"Example Documentation");
+    //outputList->writeTitle(pi->name,pi->name);
+    parseExample(*outputList,pi->doc+"\n\\include "+pi->name,pi->name);
+    endFile(*outputList);
+    pi=exampleList.next();
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate module pages
+
+void generateGroupDocs()
+{
+  GroupListIterator gli(groupList);
+  GroupDef *gd;
+  for (;(gd=gli.current());++gli)
+  {
+    //printf("group %s #members=%d\n",gd->name().data(),gd->countMembers());
+    if (gd->countMembers()>0) gd->writeDocumentation(*outputList);
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate module pages
+
+void generateNamespaceDocs()
+{
+  writeNamespaceIndex(*outputList);
+  
+  NamespaceListIterator nli(namespaceList);
+  NamespaceDef *nd;
+  for (;(nd=nli.current());++nli)
+  {
+    msg("Generating docs for namespace %s\n",nd->name().data());
+    nd->writeDocumentation(*outputList);
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate files for the search engine
+
+void generateSearchIndex()
+{
+  if (searchEngineFlag && generateHtml)
+  {
+    // create search index
+    QString fileName;
+    writeSearchButton(htmlOutputDir);
+
+    // create cgi script
+    fileName = htmlOutputDir+"/"+cgiName;
+    QFile f(fileName);
+    if (f.open(IO_WriteOnly))
+    {
+      QTextStream t(&f);
+      t << "#!/bin/sh"   << endl
+        << "DOXYSEARCH=" << binAbsPath << "/doxysearch" << endl
+        << "DOXYPATH="   << docAbsPath << " ";
+
+      char *s=extDocPathList.first();
+      while (s)
+      {
+        t << s << " ";
+        s=extDocPathList.next();
+      }
+
+      t << endl 
+        << "if [ -f $DOXYSEARCH ]" << endl
+        << "then" << endl
+        << "  $DOXYSEARCH $DOXYPATH" << endl 
+        << "else" << endl
+        << "  echo \"Content-Type: text/html\"" << endl
+        << "  echo \"\"" << endl
+        << "  echo \"<H1>Error: $DOXYSEARCH not found. Check cgi script!\"" << endl
+        << "fi" << endl;
+
+      f.close();
+      struct stat stat_struct;
+      stat(fileName,&stat_struct);
+#if !defined(_WIN32)
+      chmod(fileName,stat_struct.st_mode|S_IXUSR|S_IXGRP|S_IXOTH);
+#endif
+    }
+    else
+    {
+      err("Error: Cannot open file %s for writing\n",fileName.data());
+    }
+    
+    // create config file
+    fileName = htmlOutputDir+"/search.cfg";
+    f.setName(fileName);
+    if (f.open(IO_WriteOnly))
+    {
+      QTextStream t(&f);
+      t << docURL << endl << cgiURL << "/" << cgiName << endl;
+      f.close();
+    }
+    else
+    {
+      err("Error: Cannot open file %s for writing\n",fileName.data());
+    }
+    //outputList->generateExternalIndex();
+    outputList->disableAllBut(OutputGenerator::Html);
+    startFile(*outputList,"header.html","Search Engine",TRUE);
+    outputList->endPlainFile();
+    outputList->startPlainFile("footer.html");
+    endFile(*outputList,TRUE);
+    outputList->enableAll();
+  }
+}
+
+//----------------------------------------------------------------------------
+// generate the configuration file
+
+void generateConfigFile(const char *configFile,bool shortList)
+{
+  QFileInfo fi(configFile);
+  QFile f(configFile);
+ 
+  if (fi.exists()) // create a backup
+  {
+    QDir dir=fi.dir();
+    dir.rename(fi.fileName(),fi.fileName()+".bak");
+  } 
+  if (f.open(IO_WriteOnly))
+  {
+    writeTemplateConfig(&f,shortList);
+    f.close();
+    msg("\n\nConfiguration file `%s' created.\n\n",configFile);
+    msg("Now edit the configuration file and enter\n\n");
+    if (strcmp(configFile,"Doxyfile") || strcmp(configFile,"doxyfile"))
+      msg("  doxygen %s\n\n",configFile);
+    else
+      msg("  doxygen\n\n");
+    msg("to generate the documentation for your project\n\n");
+  }
+  else
+  {
+    err("Error: Cannot open file %s for writing\n");
+    exit(1);
+  }
+}
+
+//----------------------------------------------------------------------------
+// read and parse a tag file
+
+bool readLineFromFile(QFile &f,QString &s)
+{
+  char c=0;
+  s.resize(0);
+  while (!f.atEnd() && (c=f.getch())!='\n') s+=c;
+  return f.atEnd();
+}
+
+void readTagFile(const char *file)
+{
+  QFileInfo fi(file);
+  if (!fi.exists() || !fi.isFile())
+  {
+    err("Error: Tag file `%s' does not exist or is not a file\n",file);
+    exit(1);
+  }
+  msg("Reading tag file %s...\n",file);
+  parseTagFile(file);
+}
+
+//----------------------------------------------------------------------------
+// returns TRUE if the name of the file represented by `fi' matches
+// one of the file patterns in the `patList' list.
+
+bool patternMatch(QFileInfo *fi,QStrList *patList)
+{
+  bool found=FALSE;
+  if (patList)
+  { 
+    char *pattern=patList->first();
+    while (pattern && !found)
+    {
+      found = found || QDir::match(pattern,fi->fileName()); 
+      pattern=patList->next();
+    }
+  }
+  return found;
+}
+
+//----------------------------------------------------------------------------
+// reads a file into an array and filters out any 0x00 and 0x06 bytes,
+// because these are special for the parser.
+
+void copyAndFilterFile(const char *fileName,BufStr &dest)
+{
+  // try to open file
+  int size=0;
+  uint oldPos = dest.curPos();
+
+  QFileInfo fi(fileName);
+  if (!fi.exists()) return;
+  if (inputFilter.isEmpty())
+  {
+    QFile f(fileName);
+    if (!f.open(IO_ReadOnly))
+    {
+      err("Error: could not open file %s\n",fileName);
+      return;
+    }
+    size=fi.size();
+    // read the file
+    dest.skip(size);
+    if (f.readBlock(dest.data()+oldPos,size)!=size)
+    {
+      err("Error while reading file %s\n",fileName);
+      return;
+    }
+  }
+  else
+  {
+    int c;
+//    char *p=dest;
+    QString cmd=inputFilter+" "+fileName;
+    FILE *f=popen(cmd,"r");
+    if (!f)
+    {
+      err("Error: could not execute filter %s\n",inputFilter.data());
+      return;
+    }
+    while ((c=fgetc(f))!=EOF) dest.addChar(c),size++;
+  }
+  // filter unwanted bytes from the resulting data
+  uchar *p=(uchar *)dest.data()+oldPos;
+  uchar conv[256];
+  int i;
+  for (i=0;i<256;i++) conv[i]=i;
+  conv[0x06]=0x20; // replace the offending characters with spaces
+  conv[0x00]=0x20;
+  // remove any special markers from the input
+  for (i=0;i<size;i++,p++) *p=conv[*p];
+  // adjust pointer
+}
+
+//----------------------------------------------------------------------------
+// Reads a file to a string.
+// The name of the file is written in front of the file's contents and
+// between 0x06 markers
+
+
+void readFiles(BufStr &output)
+{
+  QString *s=inputFiles.first();
+//  char *p=output.data();
+  while (s)
+  {
+    QString fileName=*s;
+
+    //int fileSize=fi->fileInfo()->size();
+    int fileNameSize=fileName.length();
+    //int streamLength=fileSize+fileNameSize+4; 
+
+    //QString fileText(streamLength);
+
+    // add begin filename marker
+//    *p++=0x06; 
+    output.addChar(0x06);
+    // copy filename
+//    memcpy(p,fileName.data(),fileNameSize);
+//    p+=fileNameSize;
+    output.addArray(fileName.data(),fileNameSize);
+    
+    // add end filename marker
+//    *p++=0x06;
+    output.addChar(0x06);
+//    *p++='\n'; // to make ^ work while scanning the first line of a file!
+    output.addChar('\n');
+    if (preprocessingFlag)
+    {
+      msg("Preprocessing %s...\n",s->data());
+      preprocessFile(fileName,output);
+    }
+    else
+    {
+      msg("Reading %s...\n",s->data());
+      copyAndFilterFile(fileName,output);
+    }
+
+    s=inputFiles.next();
+  }
+//  *p++='\0';
+  output.addChar(0);
+  //printf("Output after preprocessing:\n---------\n%s\n----------\n",output.data());
+  //printf("Final length = %d\n",p-output.data());
+}
+
+//----------------------------------------------------------------------------
+// Read all files matching at least one pattern in `patList' in the 
+// directory represented by `fi'.
+// The directory is read iff the recusiveFlag is set.
+// The contents of all files is append to the input string
+
+int readDir(QFileInfo *fi,
+            FileNameList *fnList,
+            FileNameDict *fnDict,
+            StringDict  *exclDict,
+            QStrList *patList,
+            QStrList *exclPatList,
+            StringList *resultList,
+            StringDict *resultDict
+           )
+{
+  QDir dir((const char *)fi->absFilePath());
+  dir.setFilter( QDir::Files | QDir::Dirs );
+  int totalSize=0;
+  
+  const QFileInfoList *list = dir.entryInfoList();
+  QFileInfoListIterator it( *list );
+  QFileInfo *cfi;
+  
+  while ((cfi=it.current()))
+  {
+    if (exclDict==0 || exclDict->find(cfi->absFilePath())==0) 
+    { // file should not be excluded
+      if (!cfi->exists() || !cfi->isReadable())
+      {
+         err("Error: source %s is not a readable file or directory... skipping.\n",cfi->absFilePath().data());
+      }
+      else if (cfi->isFile() && 
+          patternMatch(cfi,patList) && !patternMatch(cfi,exclPatList))
+      {
+        totalSize+=cfi->size()+cfi->absFilePath().length()+3;
+        QString name=cfi->fileName();
+        if (fnDict)
+        {
+          FileDef  *fd=new FileDef(cfi->dirPath()+"/",name);
+          FileName *fn=0;
+          if (name.length()>0 && (fn=(*fnDict)[name]))
+          {
+            fn->append(fd);
+          }
+          else
+          {
+            fn = new FileName(name);
+            fn->append(fd);
+            if (fnList) fnList->inSort(fn);
+            fnDict->insert(name,fn);
+          }
+        }
+        QString *rs=0;
+        if (resultList || resultDict)
+        {
+          rs=new QString(cfi->absFilePath());
+        }
+        if (resultList) resultList->append(rs);
+        if (resultDict) resultDict->insert(cfi->absFilePath(),rs);
+      }
+      else if (recursiveFlag && cfi->isDir() && cfi->fileName()!="." && 
+          cfi->fileName()!="..")
+      {
+        cfi->setFile(cfi->absFilePath());
+        totalSize+=readDir(cfi,fnList,fnDict,exclDict,
+            patList,exclPatList,resultList,resultDict);
+      }
+    }
+    ++it;
+  }
+  return totalSize;
+}
+
+//----------------------------------------------------------------------------
+// read the file with name `name' into a string.
+
+QString readExampleFile(const char *name)
+{
+  QString example;
+  QFileInfo fi(name);
+  if (fi.exists())
+  {
+    QFile f((const char *)fi.absFilePath());
+    if (f.open(IO_ReadOnly))
+    {
+      example.resize(fi.size()+1);
+      if ((int)fi.size()!=f.readBlock(example.data(),fi.size()))
+      {
+        err("Error while reading file %s\n",fi.absFilePath().data());
+        //exit(1);
+        return "";
+      }
+      example.at(fi.size())='\0';
+    }
+    else
+    {
+      err("Error opening file %s\n",fi.absFilePath().data());
+      //exit(1);
+      return "";
+    }
+  }
+  else
+  {
+    err("Error: example file %s does not exist\n",name);
+    exit(1);
+  }
+  return example;
+}
+
+//----------------------------------------------------------------------------
+// read a file or all files in a directory and append their contents to the
+// input string. The names of the files are appended to the `fiList' list.
+
+int readFileOrDirectory(const char *s,
+                        FileNameList *fnList,
+                        FileNameDict *fnDict,
+                        StringDict *exclDict,
+                        QStrList *patList,
+                        QStrList *exclPatList,
+                        StringList *resultList,
+                        StringDict *resultDict
+                       )
+{
+  QFileInfo fi(s);
+  int totalSize=0;
+  {
+    if (exclDict==0 || exclDict->find(fi.absFilePath())==0)
+    {
+      if (!fi.exists() || !fi.isReadable())
+      {
+        err("Error: source %s is not a readable file or directory... skipping.\n",s);
+      }
+      else if (fi.isFile()) 
+      {
+        totalSize+=fi.size()+fi.absFilePath().length()+3; //readFile(&fi,fiList,input); 
+        //fiList->inSort(new FileInfo(fi));
+        QString name=fi.fileName();
+        if (fnDict)
+        {
+          FileDef  *fd=new FileDef(fi.dirPath(TRUE)+"/",name);
+          FileName *fn=0;
+          if (name.length()>0 && (fn=(*fnDict)[name]))
+          {
+            fn->append(fd);
+          }
+          else
+          {
+            fn = new FileName(name);
+            fn->append(fd);
+            if (fnList) fnList->inSort(fn);
+            fnDict->insert(name,fn);
+          }
+        }
+        QString *rs=0;
+        if (resultList || resultDict)
+        {
+          rs=new QString(fi.absFilePath());
+        }
+        if (resultList) resultList->append(rs);
+        if (resultDict) resultDict->insert(fi.absFilePath(),rs);
+      }
+      else if (fi.isDir()) // readable dir
+        totalSize+=readDir(&fi,fnList,fnDict,exclDict,patList,
+            exclPatList,resultList,resultDict);
+    }
+  }
+  return totalSize;
+}
+
+//----------------------------------------------------------------------------
+
+void readFormulaRepository()
+{
+  QFile f(htmlOutputDir+"/formula.repository");
+  if (f.open(IO_ReadOnly)) // open repository
+  {
+    QTextStream t(&f);
+    QString line;
+    while (!t.eof())
+    {
+      line=t.readLine();
+      int se=line.find(':'); // find name and text separator.
+      if (se==-1)
+      {
+        warn("Warning: formula.repository is corrupted!\n");
+        break;
+      }
+      else
+      {
+        QString formName = line.left(se);
+        QString formText = line.right(line.length()-se-1); 
+        Formula *f=new Formula(formText);
+        formulaList.append(f);
+        formulaDict.insert(formText,f);
+        formulaNameDict.insert(formName,f);
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+// print the usage of doxygen
+
+void usage(const char *name)
+{
+  msg("Doxygen version %s\nCopyright Dimitri van Heesch 1997-1999\n\n",versionString);
+  msg("You can use doxygen in two ways:\n\n");
+  msg("1) Use doxygen to generate a template configuration file:\n");
+  msg("    %s [-s] -g [configName]\n\n",name);
+  msg("    if -s is specified the comments in the config file will be omitted.\n\n");
+  msg("2) Use doxygen to generate documentation using an existing ");
+  msg("configuration file:\n");
+  msg("    %s [configName]\n\n",name);
+  msg("If configName is omitted `Doxyfile' will be used as a default.\n\n");
+  exit(1);
+}
+
+//----------------------------------------------------------------------------
+// read the argument of option `c' from the comment argument list and
+// update the option index `optind'.
+
+const char *getArg(int argc,char **argv,int &optind)
+{
+  char *s=0;
+  if (strlen(&argv[optind][2])>0)
+    s=&argv[optind][2];
+  else if (optind+1<argc)
+    s=argv[++optind];
+  return s;
+}
+
+//----------------------------------------------------------------------------
+
+int main(int argc,char **argv)
+{
+
+  initPreprocessor();
+  
+  /**************************************************************************
+   *             Handle arguments                                           *
+   **************************************************************************/
+
+  char *s;
+  int optind=1;
+  const char *configName=0;
+  const char *debugLabel;
+  bool genConfig=FALSE;
+  bool shortList=FALSE;
+  while (optind<argc && argv[optind][0]=='-')
+  {
+    switch(argv[optind][1])
+    {
+      case 'g':
+        genConfig=TRUE;
+        configName=getArg(argc,argv,optind);
+        if (!configName) configName="Doxyfile";
+        break;
+      case 'd':
+        debugLabel=getArg(argc,argv,optind);
+        Debug::setFlag(debugLabel);
+        break;
+      case 's':
+        shortList=TRUE;
+        break;
+      case 'h':
+      case '?':
+        usage(argv[0]);
+        break;
+      default:
+        err("Unknown option -%c\n",argv[optind][1]);
+        usage(argv[0]);
+    }
+    optind++;
+  }
+  
+  /**************************************************************************
+   *            Parse or generate the config file                           *
+   **************************************************************************/
+
+  if (genConfig)
+  {
+    generateConfigFile(configName,shortList);
+    exit(1);
+  }
+  
+  QFileInfo configFileInfo1("Doxyfile"),configFileInfo2("doxyfile");
+  QString config;
+  if (optind>=argc)
+  { 
+    if (configFileInfo1.exists()) 
+      config=fileToString("Doxyfile");
+    else if (configFileInfo2.exists())
+    {
+      config=fileToString("doxyfile");
+    }
+    else
+    {
+      err("Doxyfile not found and no input file specified!\n");
+      usage(argv[0]);
+    }
+  }
+  else
+    config=fileToString(argv[1]);
+
+  parseConfig(config); 
+  
+  /**************************************************************************
+   *            Initialize output generators                                *
+   **************************************************************************/
+
+  outputList = new OutputList(TRUE);
+  if (generateHtml)  
+  {
+    outputList->add(new HtmlGenerator);
+    HtmlGenerator::init();
+  }
+  if (generateLatex) 
+  {
+    outputList->add(new LatexGenerator);
+    LatexGenerator::init();
+  }
+  if (generateMan)
+  {
+    outputList->add(new ManGenerator);
+    ManGenerator::init();
+  }
+  
+  /**************************************************************************
+   *             Read and preprocess input                                  *
+   **************************************************************************/
+
+  // gather names of all files in the include path
+  msg("Searching for include files...\n");
+  s=includePath.first();
+  while (s)
+  {
+    readFileOrDirectory(s,0,&includeNameDict,0,&filePatternList,
+                        &excludePatternList,0,0);
+    s=includePath.next(); 
+  }
+  
+  msg("Searching for example files...\n");
+  s=examplePath.first();
+  while (s)
+  {
+    readFileOrDirectory(s,0,&exampleNameDict,0,&filePatternList,
+                        &excludePatternList,0,0);
+    s=examplePath.next(); 
+  }
+
+  msg("Searching for files to exclude\n");
+  s=excludeSources.first();
+  while (s)
+  {
+    readFileOrDirectory(s,0,0,0,&filePatternList,
+                        0,0,&excludeNameDict);
+    s=excludeSources.next();
+  }
+
+  msg("Reading input files...\n");
+  int inputSize=0;
+  s=inputSources.first();
+  while (s)
+  {
+    inputSize+=readFileOrDirectory(s,&inputNameList,
+                                   &inputNameDict,&excludeNameDict,
+                                   &filePatternList,&excludePatternList,
+                                   &inputFiles,0);
+    s=inputSources.next();
+  }
+  //msg("Input size %d bytes\n",inputSize);
+  
+  BufStr input(inputSize+1); // Add one byte extra for \0 termination
+  readFiles(input);
+
+  if (input.length()==0)
+  {
+    warn("No input read, no output generated!\n");
+    exit(1);
+  }
+  else
+  {
+    msg("Read %d bytes\n",input.length());
+  }
+
+  /**************************************************************************
+   *             Handle Tag Files                                           *
+   **************************************************************************/
+
+  msg("Reading tag files\n");
+  
+  s=tagFileList.first();
+  while (s)
+  {
+    readTagFile(s);
+    s=tagFileList.next();
+  }
+  
+  QFile *tag =new QFile(genTagFile);
+  if (genTagFile.length()>0)
+  {
+    if (!tag->open(IO_WriteOnly))
+    {
+      err("Error: cannot open tag file %s for writing\n",genTagFile.data());
+      exit(1);
+    }
+    tagFile.setDevice(tag);
+  }
+  
+  /**************************************************************************
+   *             Gather information                                         * 
+   **************************************************************************/
+  
+  // Notice: the order of the function calls below is very important!
+  
+  if (generateHtml)
+  {
+    msg("Reading formula repository...\n");
+    readFormulaRepository();
+  }
+  
+  Entry *root=new Entry;
+  root->program=input;
+
+  msg("Parsing input...\n");
+  parseMain(root);            // build a tree of entries
+
+  msg("Freeing input...\n");
+  input.resize(0);
+  
+  msg("Building namespace list...\n");
+  buildNamespaceList(root);
+  
+  msg("Building group list...\n");
+  buildGroupList(root);
+
+  //msg("Computing group relations...\n");
+  //computeGroupRelations(root); 
+  
+  msg("Building file list...\n");
+  buildFileList(root);
+  
+  msg("Building class list...\n");
+  buildClassList(root);
+  
+  msg("Building example list...\n");
+  buildExampleList(root);
+  
+  msg("Building page list...\n");
+  buildPageList(root);
+  
+//  msg("Adding compounds to file pages...\n");
+//  findClassDefsInFiles(root);
+
+  msg("Building member list...\n"); // using class info only !
+  buildMemberList(root);
+  transferFunctionDocumentation();
+
+  msg("Searching for friends...\n");
+  findFriends();
+
+  
+  msg("Searching for documented variables...\n");
+  buildVarList(root);
+  
+  msg("Searching for documented defines...\n");
+  findDefineDocumentation(root); 
+  
+  msg("Computing class relations...\n");
+  computeClassRelations(root);
+
+  msg("Searching for enumerations...\n");
+  findEnums(root);
+  findEnumDocumentation(root);
+
+//  msg("Searching for function prototypes...\n");
+//  findPrototypes(root); // may introduce new members !
+  
+  msg("Searching for member function documentation...\n");
+  findMemberDocumentation(root); // may introduce new members !
+  
+  msg("Freeing entry tree\n");
+  delete root;
+  
+  msg("Computing member references...\n");
+  computeMemberReferences(); 
+
+  msg("Computing function references...\n");
+  computeFunctionReferences();
+  
+  msg("Computing member relations...\n");
+  computeMemberRelations();
+
+  msg("Building full member lists recursively...\n");
+  buildCompleteMemberLists();
+  
+  //unrelatedFunctionsUsed=hasUnrelatedFunctions();
+  
+  /**************************************************************************
+   *                        Generate documentation                          *
+   **************************************************************************/
+
+  // count the number of documented elements in the lists we have built. 
+  // If the result is 0 we do not generate the lists and omit the 
+  // corresponding links in the index.
+  msg("Counting data structures...\n");
+  annotatedClasses     = countAnnotatedClasses();
+  hierarchyClasses     = countClassHierarchy();
+  documentedMembers    = countMemberList();
+  documentedFunctions  = countFunctionList();
+  documentedFiles      = countFileList();
+  documentedGroups     = countGroupList();
+  documentedNamespaces = countNamespaceList();
+ 
+  // compute the shortest possible names of all files
+  // without loosing the uniqueness of the file names.
+  msg("Generating disk names...\n");
+  inputNameList.generateDiskNames();
+
+  msg("Generating example documentation...\n");
+  generateExampleDocs();
+
+  msg("Generating file documentation...\n");
+  generateFileDocs();
+  
+  msg("Generating class documentation...\n");
+  generateClassDocs();
+  
+  msg("Generating page documentation...\n");
+  generatePageDocs();
+  
+  msg("Generating group documentation...\n");
+  generateGroupDocs();
+
+  msg("Generating namespace index...\n");
+  generateNamespaceDocs();
+  
+  msg("Generating group index...\n");
+  writeGroupIndex(*outputList);
+  
+  msg("Generating example index...\n");
+  writeExampleIndex(*outputList);
+  
+  msg("Generating function index...\n");
+  writeFunctionIndex(*outputList);
+  
+//  msg("Generating define index...\n");
+//  writeDefineIndex(*outputList);
+  
+  msg("Generating page index...\n");
+  writePageIndex(*outputList);
+  
+  msg("Generating search index...\n");
+  generateSearchIndex();
+  
+  msg("Generating style sheet...\n");
+  outputList->writeStyleInfo(0); // write first part
+  outputList->disableAllBut(OutputGenerator::Latex);
+  parseDoc(*outputList,0,0,
+            theTranslator->trGeneratedAt(dateToString(TRUE),projectName)
+          );
+  outputList->writeStyleInfo(1); // write second part
+  parseDoc(*outputList,0,0, theTranslator->trWrittenBy());
+  outputList->writeStyleInfo(2); // write third part
+  parseDoc(*outputList,0,0,
+            theTranslator->trGeneratedAt(dateToString(TRUE),projectName)
+          );
+  outputList->writeStyleInfo(3); // write fourth part
+  parseDoc(*outputList,0,0, theTranslator->trWrittenBy());
+  outputList->writeStyleInfo(4); // write last part
+  outputList->enableAll();
+  
+  if (formulaList.count()>0 && generateHtml)
+  {
+    msg("Generating bitmaps for formulas in HTML...\n");
+    formulaList.generateBitmaps(htmlOutputDir);
+  }
+  
+  if (searchEngineFlag || tagFileList.count()>0)
+  {
+    msg("\nNow copy the file\n\n     %s\n\nto the directory where the CGI binaries are "
+        "located and don't forget to run\n\n",(htmlOutputDir+"/"+cgiName).data());
+    msg("     %s/installdox\n\nto replace any dummy links.\n\n",
+        htmlOutputDir.data());
+  }
+  
+  delete tag;
+  return 0;
+}