mods for doxygen-0.49-990829

1 files changed, 909 insertions, 25 deletions

diff --git a/src/memberdef.cpp b/src/memberdef.cpp
index 1321692..34061f0 100644
--- a/src/memberdef.cpp
+++ b/src/memberdef.cpp
@@ -21,6 +21,165 @@
 #include "doxygen.h"
 #include "util.h"
 #include "message.h"
+#include "htmlhelp.h"
+#include "language.h"
+
+//-----------------------------------------------------------------------------
+
+static QCString addTemplateNames(const QCString &s,const QCString &n,const QCString &t)
+{
+  QCString result;
+  QCString clRealName=n;
+  int p=0,i;
+  if ((i=clRealName.find('<'))!=-1)
+  {
+    clRealName=clRealName.left(i); // strip template specialization
+  }
+  if ((i=clRealName.findRev("::"))!=-1)
+  {
+    clRealName=clRealName.right(clRealName.length()-i-2);
+  }
+  while ((i=s.find(clRealName,p))!=-1)
+  {
+    result+=s.mid(p,i-p);
+    uint j=clRealName.length()+i;
+    if (s.length()==j || (s.at(j)!='<' && !isId(s.at(j))))
+    { // add template names
+      //printf("Adding %s+%s\n",clRealName.data(),t.data());
+      result+=clRealName+t; 
+    }
+    else 
+    { // template names already present
+      //printf("Adding %s\n",clRealName.data());
+      result+=clRealName;
+    }
+    p=i+clRealName.length();
+  }
+  result+=s.right(s.length()-p);
+  //printf("addTemplateNames(%s,%s,%s)=%s\n",s.data(),n.data(),t.data(),result.data());
+  return result;
+}
+
+static void writeDefArgumentList(OutputList &ol,ClassDef *cd,
+                                 const QCString &scopeName,MemberDef *md)
+{
+  ArgumentList *argList=md->argumentList();
+  if (argList==0) return; // member has no function like argument list
+  ol.docify(" ("); // start argument list
+  Argument *a=argList->first();
+  QCString cName;
+  if (md->scopeDefTemplateArguments())
+  {
+    cName=tempArgListToString(md->scopeDefTemplateArguments());
+  }
+  if (cd)
+  {
+    cName=cd->name();
+    int il=cName.find('<');
+    int ir=cName.findRev('>');
+    if (il!=-1 && ir!=-1 && ir>il)
+    {
+      cName=cName.mid(il,ir-il+1);
+      //printf("1. cName=%s\n",cName.data());
+    }
+    else if (cd->templateArguments())
+    {
+      cName=tempArgListToString(cd->templateArguments()); 
+      //printf("2. cName=%s\n",cName.data());
+    }
+    else // no template specifier
+    {
+      cName.resize(0);
+    }
+  }
+  //printf("~~~ %s cName=%s\n",md->name().data(),cName.data());
+  while (a)
+  {
+    QRegExp re(")(");
+    int vp;
+    if (!a->attrib.isEmpty())
+    {
+      ol.docify(a->attrib+" ");
+    }
+    if ((vp=a->type.find(re))!=-1) // argument type is a function pointer
+    {
+      QCString n=a->type.left(vp);
+      if (cName.length()>0) n=addTemplateNames(n,cd->name(),cName);
+      linkifyText(ol,scopeName,md->name(),n);
+    }
+    else // non-function pointer type
+    {
+      QCString n=a->type;
+      if (cName.length()>0) n=addTemplateNames(n,cd->name(),cName);
+      linkifyText(ol,scopeName,md->name(),n);
+    }
+    if (a->name.length()>0) // argument has a name
+    { 
+      ol.docify(" ");
+      ol.disable(OutputGenerator::Man);
+      ol.startEmphasis();
+      ol.enable(OutputGenerator::Man);
+      ol.docify(a->name);
+      ol.disable(OutputGenerator::Man);
+      ol.endEmphasis();
+      ol.enable(OutputGenerator::Man);
+    }
+    if (vp!=-1) // write the part of the argument type 
+                // that comes after the name
+    {
+      linkifyText(ol,scopeName,md->name(),a->type.right(a->type.length()-vp));
+    }
+    if (a->defval.length()>0) // write the default value
+    {
+      QCString n=a->defval;
+      if (cName.length()>0) n=addTemplateNames(n,cd->name(),cName);
+      ol.docify(" = ");
+      linkifyText(ol,scopeName,md->name(),n); 
+    }
+    a=argList->next();
+    if (a) ol.docify(", "); // there are more arguments
+  }
+  ol.docify(")"); // end argument list
+  if (argList->constSpecifier)
+  {
+    ol.docify(" const");
+  }
+  if (argList->volatileSpecifier)
+  {
+    ol.docify(" volatile");
+  }
+}
+
+static void writeTemplatePrefix(OutputList &ol,ArgumentList *al,bool br=TRUE)
+{
+  ol.docify("template<");
+  Argument *a=al->first();
+  while (a)
+  {
+    ol.docify(a->type);
+    ol.docify(a->name);
+    if (a->defval.length()!=0)
+    {
+      ol.docify(" = ");
+      ol.docify(a->defval);
+    } 
+    a=al->next();
+    if (a) ol.docify(", ");
+  }
+  ol.docify("> ");
+  if (br)
+  {
+    bool latexEnabled = ol.isEnabled(OutputGenerator::Latex);
+    bool manEnabled   = ol.isEnabled(OutputGenerator::Man);
+    if (latexEnabled) ol.disable(OutputGenerator::Latex);
+    if (manEnabled)   ol.disable(OutputGenerator::Man);
+    ol.lineBreak();
+    if (latexEnabled) ol.enable(OutputGenerator::Latex);
+    if (manEnabled)   ol.enable(OutputGenerator::Man);
+  }
+}
+
+//-----------------------------------------------------------------------------
 
 /*! Creates a new member definition.
  *  Members can be function/variables/enums/etc. inside a class or inside a 
@@ -59,11 +218,14 @@ MemberDef::MemberDef(const char *t,const char *na,const char *a,const char *e,
   enumScope=0;
   enumDeclList=0;
   scopeTAL=0;
+  membTAL=0;
   type=substituteClassNames(t);
   args=substituteClassNames(a);
   if (type.isNull()) decl=name()+args; else decl=type+" "+name()+args;
   declLine=0;
   defLine=0;
+  grpId=-1;
+  memberGroup=0;
   virt=v;
   prot=p;
   related=r;
@@ -72,6 +234,10 @@ MemberDef::MemberDef(const char *t,const char *na,const char *a,const char *e,
   exception=e;
   eUsed=FALSE;
   proto=FALSE;
+  annScope=FALSE;
+  annMemb=0;
+  annUsed=FALSE;
+  indDepth=0;
   docEnumValues=FALSE;
   // copy function template arguments (if any)
   if (tal)
@@ -203,49 +369,767 @@ QCString MemberDef::getOutputFileBase() const
   return "dummy";
 }
 
-void MemberDef::setScopeTemplateArguments(ArgumentList *tal)
+static void copyArgumentList(const ArgumentList *src,ArgumentList *dst)
+{
+  ArgumentListIterator tali(*src);
+  Argument *a;
+  for (;(a=tali.current());++tali)
+  {
+    dst->append(new Argument(*a));
+  }
+  dst->constSpecifier    = src->constSpecifier;
+  dst->volatileSpecifier = src->volatileSpecifier;
+  dst->pureSpecifier     = src->pureSpecifier;
+}
+
+void MemberDef::setScopeDefTemplateArguments(ArgumentList *tal)
 {
   // copy function arguments (if any)
   if (tal)
   {
     scopeTAL = new ArgumentList;
     scopeTAL->setAutoDelete(TRUE);
-    ArgumentListIterator tali(*tal);
-    Argument *a;
-    for (;(a=tali.current());++tali)
+    copyArgumentList(tal,scopeTAL);
+  }
+}
+
+void MemberDef::setMemberDefTemplateArguments(ArgumentList *tal)
+{
+  // copy function arguments (if any)
+  if (tal)
+  {
+    membTAL = new ArgumentList;
+    membTAL->setAutoDelete(TRUE);
+    copyArgumentList(tal,membTAL);
+  }
+}
+
+
+
+void MemberDef::setGroupId(int groupId)
+{ 
+  grpId=groupId; 
+  if (grpId!=-1) 
+  {
+    memberGroup=memberGroupDict[grpId];
+    memberGroup->insertMember(this);
+  }
+}
+
+void MemberDef::writeLink(OutputList &ol,ClassDef *cd,NamespaceDef *nd,
+                      FileDef *fd,MemberGroup *mg)
+{
+  if (mg)
+    ol.writeObjectLink(0,mg->getOutputFileBase(),
+                       anchor(),name());
+  else if (nd)
+    ol.writeObjectLink(nd->getReference(),nd->getOutputFileBase(),
+                       anchor(),name());
+  else if (fd) 
+    ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),
+                       anchor(),name());
+  else    
+    ol.writeObjectLink(cd->getReference(),cd->getOutputFileBase(),
+                       anchor(),name());
+}
+
+void MemberDef::writeDeclaration(OutputList &ol,ClassDef *cd,NamespaceDef *nd,FileDef *fd,
+               int prevGroupId,bool inGroup)
+{
+  int i,l;
+  bool hasDocs=hasDocumentation();
+  //if (cd) printf("MemberDef: %s in class %s annScope=%d annMemb=%p\n",
+  //    name().data(),cd->name().data(),annScope,annMemb);
+  if (annScope) return;
+  if (!hasDocs && Config::hideMemberFlag) return;
+  if (Config::hideMemberFlag && documentation().isEmpty() && 
+      !Config::briefMemDescFlag && !Config::repeatBriefFlag 
+     ) return;
+  QCString type=typeString();
+  // strip `static' keyword from type
+  if (type.left(7)=="static ") type=type.right(type.length()-7);
+  // strip `friend' keyword from type
+  if (type.left(7)=="friend ") type=type.right(type.length()-7);
+  QRegExp r("@[0-9]+");
+  if ((i=r.match(type,0,&l))==-1 || !enumUsed())
+  {
+    
+    if (Config::genTagFile.length()>0)
+    {
+      tagFile << name() << " " << anchor() << " \""
+              << argsString() << "\"\n";
+    }
+      
+    Definition *d=0;
+    if (cd) d=cd; else if (nd) d=nd; else d=fd;
+    QCString cname  = d->name();
+    QCString cfname = d->getOutputFileBase();
+
+    int gId = inGroup ? -1 : groupId();
+    MemberGroup *mg = (gId!=prevGroupId && gId!=-1) ? memberGroupDict[gId] : 0;
+    const char *gHeader = 0;
+    const char *gFile = 0;
+    if (mg)
+    {
+      gHeader=mg->header();
+      gFile=mg->getOutputFileBase();
+    }
+
+    if (!inGroup)
+    {
+      if (prevGroupId==-1 && gId!=-1)
+      {
+        ol.memberGroupSpacing(FALSE);
+        ol.memberGroupSeparator();
+      }
+      else if (prevGroupId!=-1 && gId==-1)
+      {
+        ol.memberGroupSpacing(TRUE);
+        ol.memberGroupSeparator();
+      }
+      else if (prevGroupId!=-1 && gId!=-1 && prevGroupId!=gId)
+      {
+        ol.memberGroupSpacing(TRUE);
+        ol.memberGroupSeparator();
+      }
+    }
+    
+    HtmlHelp *htmlHelp=0;
+    bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
+    if (hasHtmlHelp) htmlHelp = HtmlHelp::getInstance();
+    
+    // search for the last annonymous scope in the member type
+    ClassDef *annoClassDef=0;
+    while (i!=-1 && cname.find(type.mid(i,l))!=-1)
+    {
+      i=r.match(type,i+l,&l);
+    }
+    if (i!=-1) 
+    {
+      // get the definition of the annonymous class that is 
+      // the type of this member
+      annoClassDef=getClass(cname+"::"+type.mid(i,l));
+    }
+
+    // start a new member declaration
+    ol.startMemberItem(gId!=-1,((i!=-1) || annMemb) ? 1 : 0);
+
+    // If there is no detailed description we need to write the anchor here.
+    bool detailsVisible = detailsAreVisible();
+    if (!detailsVisible && !Config::extractAllFlag && !annMemb)
+    {
+      QCString doxyName=name().copy();
+      if (!cname.isEmpty()) doxyName.prepend(cname+"::");
+      ol.writeDoxyAnchor(cname,anchor(),doxyName);
+      ol.addToIndex(name(),cname);
+      ol.addToIndex(cname,name());
+      if (hasHtmlHelp)
+      {
+        htmlHelp->addIndexItem(cname,name(),cfname,anchor());
+      }
+      ol.docify("\n");
+    }
+    //else if (!detailsVisible) // when extractAll it true we have to write
+    //                         // a index reference and label in LaTeX because
+    //                         // detailed section not shown in LaTeX
+    //{
+    //  ol.addToIndex(name(),cname);
+    //  ol.addToIndex(cname,name());
+    //  ol.writeLatexLabel(cname,anchor());
+    //}
+
+    if (tArgList)
+    {
+      writeTemplatePrefix(ol,tArgList,FALSE);
+    }
+    
+    if (i!=-1 || annMemb)
+    {
+      int j;
+      for (j=0;j<indDepth;j++) 
+      {
+        ol.writeNonBreakableSpace();
+      }
+    }
+    
+    if (i!=-1)
+    {
+      //printf("scopeName=`%s' annonymous=`%s'\n",
+      //    cname.data(),type.mid(i,l).data());
+
+      if (annoClassDef)
+      {
+        //printf("class found!\n");
+        annoClassDef->writeDeclaration(ol);
+        ol.startMemberItem(gId!=-1,2);
+        int j;
+        for (j=0;j<indDepth;j++) 
+        {
+          ol.writeNonBreakableSpace();
+        }
+        ol.docify("}");
+        ol.docify(type.right(type.length()-i-l).stripWhiteSpace());
+      }
+      else
+      {
+        type = type.left(i) + " { ... } " + type.right(type.length()-i-l);
+        linkifyText(ol,cname,name(),type); 
+      }
+    }
+    else
+    {
+      linkifyText(ol,cname,name(),type); 
+    }
+    bool htmlOn = ol.isEnabled(OutputGenerator::Html);
+    if (htmlOn && Config::htmlAlignMemberFlag && type.length()>0)
+    {
+      ol.disable(OutputGenerator::Html);
+    }
+    if (!type.isEmpty()) ol.docify(" ");
+    if (htmlOn) 
+    {
+      ol.enable(OutputGenerator::Html);
+    }
+
+    if (annMemb) 
+    {
+      bool latexOn = ol.isEnabled(OutputGenerator::Latex);
+      bool manOn   = ol.isEnabled(OutputGenerator::Latex);
+      if (latexOn) ol.disable(OutputGenerator::Latex);
+      if (manOn)   ol.disable(OutputGenerator::Man);
+      ol.writeNonBreakableSpace();
+      if (latexOn) ol.enable(OutputGenerator::Latex);
+      if (manOn)   ol.enable(OutputGenerator::Man);
+    }
+    else
+      ol.insertMemberAlign();
+    
+    // write name
+    if (grpId!=-1)
+    {
+      if (annMemb)
+      {
+        //printf("anchor=%s ann_anchor=%s\n",anchor(),annMemb->anchor());
+        annMemb->writeLink(ol,cd,nd,fd,inGroup ? memberGroup : 0);
+        annMemb->annUsed=annUsed=TRUE;
+      }
+      else
+        writeLink(ol,0,0,0,memberGroup);
+      //ol.writeBoldString(name()); 
+    }
+    else if (isLinkable())
+    {
+      if (annMemb)
+      {
+        //printf("anchor=%s ann_anchor=%s\n",anchor(),annMemb->anchor());
+        annMemb->writeLink(ol,annMemb->memberClass(),nd,fd,inGroup ? memberGroup : 0);
+        annMemb->annUsed=annUsed=TRUE;
+      }
+      else
+        //printf("writeLink %s->%d\n",name.data(),hasDocumentation());
+        writeLink(ol,cd,nd,fd,inGroup ? memberGroup : 0);
+    }
+    else // there is a brief member description and brief member 
+         // descriptions are enabled or there is no detailed description.
     {
-      scopeTAL->append(new Argument(*a));
+      if (annMemb) annMemb->annUsed=annUsed=TRUE;
+      ol.writeBoldString(name());
+    }
+
+    // if member template specifiers are not part of the name, but they are
+    // present, we add them
+    if (tArgList && !(name().find('<')!=-1 && name().find('>')!=-1)
+        && cd && cd->templateArguments())
+    {
+      ol.docify(tempArgListToString(tArgList));
+    }
+
+    if (argsString()) 
+    {
+      ol.writeString(" ");
+      //ol.docify(argsString());
+      linkifyText(ol,cname,name(),argsString()); 
+    }
+    
+    if (excpString())
+    {
+      ol.writeString(" ");
+      ol.docify(excpString());
+    }
+
+    ol.endMemberItem(gId!=-1,gFile,gHeader,annoClassDef!=0 && indDepth==0);
+
+    // write brief description
+    if (!briefDescription().isEmpty() && Config::briefMemDescFlag && 
+        gId==-1 && !inGroup && !annMemb)
+    {
+      ol.startMemberDescription();
+      parseDoc(ol,cname,name(),briefDescription());
+      if (!documentation().isEmpty()) 
+      {
+        ol.disableAllBut(OutputGenerator::Html);
+        ol.endEmphasis();
+        ol.docify(" ");
+        ol.startTextLink(0,anchor());
+        parseText(ol,theTranslator->trMore());
+        ol.endTextLink();
+        ol.startEmphasis();
+        ol.enableAll();
+      }
+      ol.endMemberDescription();
+      ol.newParagraph();
     }
-    scopeTAL->constSpecifier    = tal->constSpecifier;
-    scopeTAL->volatileSpecifier = tal->volatileSpecifier;
-    scopeTAL->pureSpecifier     = tal->pureSpecifier;
   }
+  warnIfUndocumented();
 }
 
-QCString MemberDef::getScopeTemplateNameString()
+
+void MemberDef::writeDocumentation(MemberList *ml,OutputList &ol,const char *scopeName,
+                MemberType m)
 {
-  QCString result;
-  if (!scopeTAL || scopeTAL->count()==0) return result;
-  result="<";
-  Argument *a=scopeTAL->first();
-  while (a)
+  bool hasDocs = detailsAreVisible();
+  if (
+       (memberType()==m &&                          // filter member type
+       (Config::extractAllFlag || hasDocs) &&
+       groupId()==-1 
+      ) || /* member is part of an annonymous scope that is the type of
+            * another member in the list.
+            */ 
+      (!hasDocs && !briefDescription().isEmpty() && annUsed)
+     )
   {
-    if (a->name.length()>0) // add template argument name
+    //printf("************* Writing docs for member %s\n",name().data());
+    //if (Config::extractAllFlag && !hasDocs) 
+    //{
+    // ol.disable(OutputGenerator::Latex); // Latex cannot insert a pagebreak 
+    //                                      // if there are a lot of empty sections,
+    //                                      // so we disable LaTeX for all empty 
+    //                                      // sections even if Config::extractAllFlag is enabled
+    //}
+    NamespaceDef *nd=getNamespace();
+    ClassDef     *cd=memberClass();
+    FileDef      *fd=getFileDef();
+    Definition   *d = 0;
+    if (cd) d=cd; else if (nd) d=nd; else d=fd;
+    QCString cname  = d->name();
+    QCString cfname = d->getOutputFileBase();  
+
+    // get member name
+    QCString doxyName=name().copy();
+    // prepend scope if there is any 
+    if (scopeName) doxyName.prepend((QCString)scopeName+"::");
+
+    QCString def = definition();
+    if (isEnumerate()) def.prepend("enum ");
+    MemberDef *smd;
+    if (isEnumValue() && def[0]=='@') def = def.right(def.length()-2);
+    int i=0,l,dummy;
+    QRegExp r("@[0-9]+");
+    if (isEnumerate() && r.match(def,0,&l)!=-1) return;
+    if (isEnumValue() && (smd = getEnumScope()) 
+        && r.match(smd->name(),0,&dummy)==-1) return;
+
+    bool hasHtmlHelp = Config::generateHtml && Config::htmlHelpFlag;
+    HtmlHelp *htmlHelp = 0;
+    if (hasHtmlHelp) htmlHelp = HtmlHelp::getInstance();
+
+    if ((isVariable() || isTypedef()) && (i=r.match(def,0,&l))!=-1)
     {
-      result+=a->name;
+      // find enum type an insert it in the definition
+      MemberListIterator vmli(*ml);
+      MemberDef *vmd;
+      bool found=FALSE;
+      for ( ; (vmd=vmli.current()) && !found ; ++vmli)
+      {
+        if (vmd->isEnumerate() && def.mid(i,l)==vmd->name())
+        {
+          ol.startMemberDoc(cname,name(),anchor());
+          if (hasHtmlHelp)
+          {
+            htmlHelp->addIndexItem(cname,name(),cfname,anchor());
+          }
+          ol.writeDoxyAnchor(cname,anchor(),doxyName);
+          linkifyText(ol,scopeName,name(),def.left(i));
+          ol+=*vmd->enumDecl();
+          linkifyText(ol,scopeName,name(),def.right(def.length()-i-l));
+          found=TRUE;
+        }
+      }
+      if (!found) // anonymous compound
+      {
+        //printf("Annonymous compound `%s'\n",cname.data());
+        ol.startMemberDoc(cname,name(),anchor());
+        if (hasHtmlHelp)
+        {
+          htmlHelp->addIndexItem(cname,name(),cfname,anchor());
+        }
+        ol.writeDoxyAnchor(cname,anchor(),doxyName);
+        // strip annonymous compound names from definition
+        int si=def.find(' '),pi,ei=i+l;
+        if (si==-1) si=0;
+        while ((pi=r.match(def,i+l,&l))!=-1) ei=i=pi+l;
+        // first si characters of def contain compound type name
+        ol.docify(def.left(si));
+        ol.docify(" { ... } ");
+        // last ei characters of def contain pointer/reference specifiers
+        linkifyText(ol,scopeName,name(),def.right(def.length()-ei));
+      }
     }
-    else // extract name from type
+    else
     {
-      int i=a->type.length()-1;
-      while (i>=0 && isId(a->type.at(i))) i--;
-      if (i>0)
+      ol.startMemberDoc(cname,name(),anchor());
+      if (hasHtmlHelp)
+      {
+        htmlHelp->addIndexItem(cname,name(),cfname,anchor());
+      }
+      ol.writeDoxyAnchor(cname,anchor(),doxyName);
+
+      ArgumentList *scopeAl=scopeDefTemplateArguments();
+      if (scopeAl==0 && cd) scopeAl=cd->templateArguments(); 
+
+      ArgumentList *membAl=memberDefTemplateArguments();
+      if (membAl==0) membAl=templateArguments();
+
+      //if (cd && (!isRelated() || templateArguments()!=0) && 
+      //    ((al=scopeDefTemplateArguments()) || (al=cd->templateArguments()))
+      //   ) 
+      if (scopeAl) // class template prefix
+      {
+        writeTemplatePrefix(ol,scopeAl);
+      }
+      if (scopeAl && membAl) ol.docify(" ");
+
+      if (membAl) // function template prefix
       {
-        result+=a->type.right(a->type.length()-i-1);
+        writeTemplatePrefix(ol,membAl);
       }
+      if (cd)
+      {
+        QCString cName=cd->name();
+        //printf("cName=%s\n",cName.data());
+        int il=cName.find('<');
+        int ir=cName.findRev('>');
+        if (il!=-1 && ir!=-1 && ir>il)
+        {
+          def=addTemplateNames(def,
+                 cName.left(il),          /* class without template spec */
+                 cName.mid(il,ir-il+1)    /* templ spec */
+              ); 
+        }
+        else if (scopeAl)
+        {
+          def=addTemplateNames(def,cName,tempArgListToString(scopeAl));
+        }
+      }
+      linkifyText(ol,scopeName,name(),def);
+      writeDefArgumentList(ol,cd,scopeName,this);
+      if (excpString())
+      {
+        ol.docify(" ");
+        linkifyText(ol,scopeName,name(),excpString());
+      }
+    }
+
+    Specifier virt=virtualness();
+    MemberDef *rmd=reimplements();
+    while (rmd && virt==Normal)
+    {
+      virt = rmd->virtualness()==Normal ? Normal : Virtual;
+      rmd  = rmd->reimplements();
+    }
+
+    if (isStatic() || protection()!=Public || 
+        virt!=Normal || isSignal() || isFriend() || 
+        isRelated() || isSlot()
+       )
+    {
+      // write the member specifier list
+      ol.writeLatexSpacing();
+      ol.startTypewriter();
+      ol.docify(" [");
+      QStrList sl;
+      if (isFriend()) sl.append("friend");
+      else if (isRelated()) sl.append("related");
+      else
+      {
+        if      (isStatic())              sl.append("static");
+        if      (protection()==Protected) sl.append("protected");
+        else if (protection()==Private)   sl.append("private");
+        if      (virt==Virtual)           sl.append("virtual");
+        else if (virt==Pure)              sl.append("pure virtual");
+        if      (isSignal())              sl.append("signal");
+        if      (isSlot())                sl.append("slot");
+      }
+      const char *s=sl.first();
+      while (s)
+      {
+        ol.docify(s);
+        s=sl.next();
+        if (s) ol.docify(", ");
+      }
+      ol.docify("]");
+      ol.endTypewriter();
+    }
+    ol.endMemberDoc();
+    ol.startIndent();
+    ol.newParagraph();
+
+    if (!briefDescription().isEmpty() && 
+        (Config::repeatBriefFlag || 
+         (!Config::briefMemDescFlag && documentation().isEmpty())
+        ) || !annMemb
+       )  
+    { 
+      parseDoc(ol,scopeName,name(),briefDescription());
+      ol.newParagraph();
+    }
+    if (!documentation().isEmpty())
+    { 
+      parseDoc(ol,scopeName,name(),documentation()+"\n");
+    }
+    if (!bodyCode().isEmpty())
+    {
+      ol.startCodeFragment();
+      parseCode(ol,scopeName,bodyCode(),FALSE,0);
+      ol.endCodeFragment();
+    }
+
+    if (isEnumerate())
+    {
+      bool first=TRUE;
+      MemberList *fmdl=enumFieldList();
+      if (fmdl)
+      {
+        MemberDef *fmd=fmdl->first();
+        while (fmd)
+        {
+          if (fmd->isLinkable())
+          {
+            if (first)
+            {
+              ol.newParagraph();
+              ol.startBold();
+              parseText(ol,theTranslator->trEnumerationValues());
+              //ol.writeBoldString("Enumeration values:");
+              ol.docify(":");
+              ol.endBold();
+              ol.startItemList();
+            }
+            ol.writeDoxyAnchor(cname,fmd->anchor(),fmd->name());
+            ol.addToIndex(fmd->name(),cname);
+            ol.addToIndex(cname,fmd->name());
+            if (Config::generateHtml && Config::htmlHelpFlag)
+            {
+              HtmlHelp::getInstance()->addIndexItem(cname,fmd->name(),cfname,fmd->anchor());
+            }
+            ol.writeListItem();
+            first=FALSE;
+            ol.startBold();
+            ol.docify(fmd->name());
+            ol.endBold();
+            ol.newParagraph();
+
+            if (!fmd->briefDescription().isEmpty())
+            { 
+              parseDoc(ol,scopeName,fmd->name(),fmd->briefDescription());
+              ol.newParagraph();
+            }
+            if (!fmd->documentation().isEmpty())
+            { 
+              parseDoc(ol,scopeName,fmd->name(),fmd->documentation()+"\n");
+            }
+            ol.disable(OutputGenerator::Man);
+            ol.newParagraph();
+            ol.enable(OutputGenerator::Man);
+          }
+          fmd=fmdl->next();
+        }
+      }
+      if (!first) { ol.endItemList(); ol.writeChar('\n'); }
+    }
+
+    MemberDef *bmd=reimplements();
+    ClassDef  *bcd=0; 
+    if (bmd && (bcd=bmd->memberClass()))
+    {
+      if (virt!=Normal) // search for virtual member of the deepest base class
+      {
+        MemberDef *lastBmd=bmd;
+        while (lastBmd) 
+        {
+          ClassDef *lastBcd = lastBmd->memberClass();
+          if (lastBmd->virtualness()!=Normal && 
+              lastBmd->isLinkable() &&
+              lastBcd->isLinkable()
+             ) { bmd=lastBmd; bcd=lastBcd; }
+          lastBmd=lastBmd->reimplements();
+        }
+      }
+      // write class that contains a member that is reimplemented by this one
+      if (bcd->isLinkable())
+      {
+        ol.newParagraph();
+
+        QCString reimplFromLine = theTranslator->trReimplementedFromList(1);
+        int markerPos = reimplFromLine.find("@0");
+        if (markerPos!=-1) // should always pass this.
+        {
+          parseText(ol,reimplFromLine.left(markerPos)); //text left from marker
+          if (bmd->isLinkable()) // replace marker with link
+          {
+            ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
+                bmd->anchor(),bcd->name());
+            if ( bcd->isLinkableInProject()) 
+            {
+              ol.writePageRef(bcd->name(),bmd->anchor());
+            }
+          }
+          else
+          {
+            ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
+                0,bcd->name());
+            if (bcd->isLinkableInProject())
+            {
+              ol.writePageRef(bcd->name(),0);
+            }
+          }
+          parseText(ol,reimplFromLine.right(
+                reimplFromLine.length()-markerPos-2)); // text right from marker
+
+        }
+        else
+        {
+          err("Error: translation error: no marker in trReimplementsFromList()\n");
+        }
+      }
+
+      //ol.writeString(".");
     }
-    a=scopeTAL->next();
-    if (a) result+=", ";
+    MemberList *bml=reimplementedBy();
+    if (bml)
+    {
+      MemberListIterator mli(*bml);
+      MemberDef *bmd=0;
+      uint count=0;
+      ClassDef *bcd=0;
+      for (mli.toFirst();(bmd=mli.current()) && (bcd=bmd->memberClass());++mli)
+      {
+        // count the members that directly inherit from md and for
+        // which the member and class are visible in the docs.
+        if ( bmd->isLinkable() && bcd->isLinkable() ) count++;
+      }
+      if (count>0)
+      {
+        mli.toFirst();
+        // write the list of classes that overwrite this member
+        ol.newParagraph();
+        //parseText(ol,theTranslator->trReimplementedIn());
+        //ol.writeString("Reimplemented in ");
+        //ol.docify(" ");
+
+        QCString reimplInLine = 
+          theTranslator->trReimplementedInList(count);
+        QRegExp marker("@[0-9]+");
+        int index=0,newIndex,matchLen;
+        // now replace all markers in reimplInLine with links to the classes
+        while ((newIndex=marker.match(reimplInLine,index,&matchLen))!=-1)
+        {
+          parseText(ol,reimplInLine.mid(index,newIndex-index));
+          bool ok;
+          uint entryIndex = reimplInLine.mid(newIndex+1,matchLen-1).toUInt(&ok);
+          //bmd=bml->at(entryIndex);
+
+          count=0;
+          // find the entryIndex-th documented entry in the inheritance list.
+          for (mli.toFirst();(bmd=mli.current()) && (bcd=bmd->memberClass());++mli)
+          {
+            if ( bmd->isLinkable() && bcd->isLinkable()) 
+            {
+              if (count==entryIndex) break;
+              count++;
+            }
+          }
+
+          if (ok && bcd && bmd) // write link for marker
+          {
+            //if (bmd->hasDocumentation() &&
+            //    (bmd->protection()!=Private || Config::extractPrivateFlag)
+            //   )
+            //{
+            ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
+                bmd->anchor(),bcd->name());
+            if (bcd->isLinkableInProject()) 
+            {
+              ol.writePageRef(bcd->name(),bmd->anchor());
+            }
+            //}
+            //else
+            //{
+            //  ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
+            //      0,bcd->name());
+            //  if (!bcd->isReference() && bcd->isVisible()) 
+            //    ol.writePageRef(bcd->name(),0);
+            //}
+          }
+          ++mli;
+          index=newIndex+matchLen;
+        } 
+        parseText(ol,reimplInLine.right(reimplInLine.length()-index));
+
+      }
+    }
+    // write the list of examples that use this member
+    if (hasExamples())
+    {
+      ol.startDescList();
+      ol.startBold();
+      parseText(ol,theTranslator->trExamples()+": ");
+      //ol.writeBoldString("Examples: ");
+      ol.endBold();
+      ol.endDescTitle();
+      ol.writeDescItem();
+      writeExample(ol,getExampleList());
+      //ol.endDescItem();
+      ol.endDescList();
+    }
+    ol.endIndent();
+    // enable LaTeX again
+    //if (Config::extractAllFlag && !hasDocs) ol.enable(OutputGenerator::Latex); 
+
   }
-  result+=">";
-  return result;
+}
+
+void MemberDef::warnIfUndocumented()
+{
+  if (memberGroup) return;
+  ClassDef     *cd = memberClass();
+  NamespaceDef *nd = getNamespace();
+  FileDef      *fd = getFileDef();
+  Definition *d=0;
+  const char *t=0;
+  if (cd) 
+    t="class", d=cd; 
+  else if (nd) 
+    t="namespace", d=nd; 
+  else 
+    t="file", d=fd;
+
+  if (d && d->isLinkable() && !isLinkable() && name().find('@')==-1)
+   warn("Warning: Member %s of %s %s is not documented\n",
+        name().data(),t,d->name().data());
+}
+
+
+bool MemberDef::isLinkableInProject()
+{
+  return !name().isEmpty() && name().at(0)!='@' &&
+         ((hasDocumentation() && !isReference()) || 
+          (memberGroup && memberGroup->isLinkableInProject())
+         ) && 
+         (prot!=Private || Config::extractPrivateFlag || isFriend());
+}
+
+bool MemberDef::isLinkable()
+{
+  return isLinkableInProject() || isReference();
 }