memberdef.cpp

doxygen(一个自动从源代码生成文档的工具)的源代码

            ol.startEmphasis();
            ol.docify(fmd->name());
            ol.endEmphasis();
            ol.disableAllBut(OutputGenerator::Man);
            ol.writeString(" ");
            ol.enableAll();
            ol.endDoxyAnchor(cfname,fmd->anchor());
            ol.endDescTableTitle();
            //ol.newParagraph();
            ol.startDescTableData();

            if (!fmd->briefDescription().isEmpty())
            { 
              parseDoc(ol,m_defFileName,m_defLine,scopeName,fmd->name(),fmd->briefDescription());
              //ol.newParagraph();
            }
            if (!fmd->briefDescription().isEmpty() && 
                !fmd->documentation().isEmpty())
            {
              ol.newParagraph();
            }
            if (!fmd->documentation().isEmpty())
            { 
              parseDoc(ol,m_defFileName,m_defLine,scopeName,fmd->name(),fmd->documentation()+"\n");
            }
            ol.endDescTableData();
          }
          fmd=fmdl->next();
        }
      }
      if (!first) 
      { 
        //ol.endItemList(); 
        ol.endDescTable();
        ol.endDescList();
        ol.writeChar('\n'); 
      }
    }

    MemberDef *bmd=reimplements();
    ClassDef  *bcd=0; 
    if (bmd && (bcd=bmd->getClassDef()))
    {
#if 0
      if (lvirt!=Normal) // search for virtual member of the deepest base class
      {
        MemberDef *lastBmd=bmd;
        while (lastBmd) 
        {
          ClassDef *lastBcd = lastBmd->getClassDef();
          if (lastBmd->virtualness()!=Normal && 
              lastBmd->isLinkable() &&
              lastBcd->isLinkable()
             ) { bmd=lastBmd; bcd=lastBcd; }
          lastBmd=lastBmd->reimplements();
        }
      }
#endif
      // 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
          {
            Definition *bd=bmd->group;
            if (bd==0) bd=bcd;
            ol.writeObjectLink(bd->getReference(),bd->getOutputFileBase(),
                bmd->anchor(),bcd->name());
            
            //ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
            //    bmd->anchor(),bcd->name());
            if ( bd->isLinkableInProject() ) 
            {
              writePageRef(ol,bd->getOutputFileBase(),bmd->anchor());
            }
          }
          else
          {
            ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
                0,bcd->name());
            if (bcd->isLinkableInProject()/* && !Config_getBool("PDF_HYPERLINKS")*/ )
            {
              writePageRef(ol,bcd->getOutputFileBase(),0);
            }
          }
          parseText(ol,reimplFromLine.right(
                reimplFromLine.length()-markerPos-2)); // text right from marker

          ol.disableAllBut(OutputGenerator::RTF);
          ol.newParagraph();
          ol.enableAll();
        }
        else
        {
          err("Error: translation error: no marker in trReimplementsFromList()\n");
        }
      }

      //ol.writeString(".");
    }
    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->getClassDef());++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();

        QCString reimplInLine = 
          theTranslator->trReimplementedInList(count);
        static 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.toLast();(bmd=mli.current()) && (bcd=bmd->getClassDef());--mli)
          {
            if ( bmd->isLinkable() && bcd->isLinkable()) 
            {
              if (count==entryIndex) break;
              count++;
            }
          }

          if (ok && bcd && bmd) // write link for marker
          {
            //ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
            //    bmd->anchor(),bcd->name());
            Definition* bd;
            if (bmd->group) bd=bmd->group; else bd=bcd;
            
            ol.writeObjectLink(bd->getReference(),bd->getOutputFileBase(),
                bmd->anchor(),bcd->name());
                
            if (bd->isLinkableInProject() ) 
            {
              writePageRef(ol,bd->getOutputFileBase(),bmd->anchor());
            }
          }
          ++mli;
          index=newIndex+matchLen;
        } 
        parseText(ol,reimplInLine.right(reimplInLine.length()-index));
        ol.disableAllBut(OutputGenerator::RTF);
        ol.newParagraph();
        ol.enableAll();
      }
    }
    // write the list of examples that use this member
    if (hasExamples())
    {
      ol.startDescList(BaseOutputDocInterface::Examples);
      parseText(ol,theTranslator->trExamples()+": ");
      //ol.writeBoldString("Examples: ");
      ol.endDescTitle();
      ol.writeDescItem();
      writeExample(ol,getExamples());
      //ol.endDescItem();
      ol.endDescList();
    }
    // write reference to the source
    writeSourceDef(ol,cname);
    writeSourceRefs(ol,cname);
    writeSourceReffedBy(ol,cname);
    writeInlineCode(ol,cname);

    ol.endIndent();
    // enable LaTeX again
    //if (Config_getBool("EXTRACT_ALL") && !hasDocs) ol.enable(OutputGenerator::Latex); 
    ol.popGeneratorState();

  }
}

void MemberDef::warnIfUndocumented()
{
  if (memberGroup) return;
  ClassDef     *cd = getClassDef();
  NamespaceDef *nd = getNamespaceDef();
  FileDef      *fd = getFileDef();
  GroupDef     *gd = getGroupDef();
  Definition *d=0;
  const char *t=0;
  if (cd) 
    t="class", d=cd; 
  else if (nd) 
    t="namespace", d=nd; 
  else if (gd)
    t="group", d=gd;
  else
    t="file", d=fd;

  if (d && d->isLinkable() && !isLinkable() && !isDocumentedFriendClass()
      && name().find('@')==-1)
   warn_undoc(m_defFileName,m_defLine,"Warning: Member %s of %s %s is not documented.",
        name().data(),t,d->name().data());
}


bool MemberDef::isLinkableInProject() const
{
  if (m_templateMaster)
  {
    return m_templateMaster->isLinkableInProject();
  }
  else
  {
    return !name().isEmpty() && name().at(0)!='@' &&
      (hasDocumentation() && !isReference()) && 
      (prot!=Private || Config_getBool("EXTRACT_PRIVATE") || 
      mtype==Friend) && // not a hidden member due to protection
      (classDef!=0 || Config_getBool("EXTRACT_STATIC") || 
      !isStatic()); // not a static file/namespace member
  }
}

bool MemberDef::isLinkable() const
{
  if (m_templateMaster)
  {
    return m_templateMaster->isLinkable();
  }
  else
  {
    return isLinkableInProject() || isReference();
  }
}

void MemberDef::setEnumDecl(OutputList &ed) 
{ 
  enumDeclList=new OutputList(&ed); 
  *enumDeclList+=ed;
}

bool MemberDef::isDocumentedFriendClass() const
{
  ClassDef *fcd=0;
  return (isFriend() && 
         (type=="friend class" || type=="friend struct" || 
          type=="friend union") &&
         (fcd=getClass(name())) && fcd->isLinkable()); 
}

bool MemberDef::hasDocumentation() const
{ 
  return Definition::hasDocumentation() || 
         (mtype==Enumeration && docEnumValues) ||  // has enum values
         (argList!=0 && argList->hasDocumentation()); // has doc arguments
}

void MemberDef::setMemberGroup(MemberGroup *grp)
{
  memberGroup = grp;
}

bool MemberDef::visibleMemberGroup(bool hideNoHeader) 
{ 
  return memberGroup!=0 && 
          (!hideNoHeader || memberGroup->header()!="[NOHEADER]"); 
}

QCString MemberDef::getScopeString() const
{
  QCString result;
  if (getClassDef()) result=getClassDef()->name();
  else if (getNamespaceDef()) result=getNamespaceDef()->name();
  return result;
}


//Definition *MemberDef::getCompoundDef() const
//{
//    NamespaceDef *nd=getNamespaceDef();
//    ClassDef     *cd=getClassDef();
//    FileDef      *fd=getFileDef();
//    GroupDef     *gd=getGroupDef();
//    Definition   *d = 0;
//    if (cd) d=cd; else if (nd) d=nd; else if (gd) d=gd; else d=fd;
//    ASSERT(d!=0);
//    return d;
//}

QCString MemberDef::anchor() const
{
  if (m_templateMaster) return m_templateMaster->anchor();
  if (enumScope) return enumScope->anchor()+anc;
  return anc;
}

void MemberDef::setGroupDef(GroupDef *gd,Grouping::GroupPri_t pri,const QCString &fileName,int startLine,bool hasDocs)
{
  //printf("%s MemberDef::setGroupDef(%s)\n",name().data(),gd->name().data());
  group=gd;
  grouppri=pri;
  groupFileName=fileName;
  groupStartLine=startLine;
  groupHasDocs=hasDocs;
}

void MemberDef::setEnumScope(MemberDef *md) 
{ 
  enumScope=md; 
  if (md->group)
  {
    group=md->group;
    grouppri=md->grouppri;
    groupFileName=md->groupFileName;
    groupStartLine=md->groupStartLine;
    groupHasDocs=md->groupHasDocs;
  }
}

void MemberDef::setMemberClass(ClassDef *cd)     
{ 
  classDef=cd; 
  setOuterScope(cd); 
}

void MemberDef::setNamespace(NamespaceDef *nd) 
{ 
  nspace=nd; 
  setOuterScope(nd); 
}

MemberDef *MemberDef::createTemplateInstanceMember(
        ArgumentList *formalArgs,ArgumentList *actualArgs)
{
  //printf("  Member %s %s %s\n",typeString(),name().data(),argsString());
  ArgumentList *actualArgList = 0;
  if (argList)
  {
    actualArgList = new ArgumentList;
    ArgumentListIterator ali(*argList);
    Argument *arg;
    for (;(arg=ali.current());++ali)
    {
      Argument *actArg = new Argument(*arg);
      actArg->type = substituteTemplateArgumentsInString(actArg->type,formalArgs,actualArgs);
      actualArgList->append(actArg);
    }
  }

  MemberDef *imd = new MemberDef(
                       getDefFileName(),getDefLine(),
                       substituteTemplateArgumentsInString(type,formalArgs,actualArgs), 
                       name(), 
                       substituteTemplateArgumentsInString(args,formalArgs,actualArgs), 
                       exception, prot,
                       virt, stat, related, mtype, 0, 0
                   );
  imd->argList = actualArgList;
  imd->def = substituteTemplateArgumentsInString(def,formalArgs,actualArgs);
  // TODO: init other member variables.
  return imd; 
}

bool MemberDef::hasOneLineInitializer() const
{
  //printf("%s: init=%s, initLines=%d maxInitLines=%d userInitLines=%d\n",
  //    name().data(),init.data(),initLines,maxInitLines,userInitLines);
  return !init.isEmpty() && initLines==0 && // one line initializer
         ((maxInitLines>0 && userInitLines==-1) || userInitLines>0); // enabled by default or explicitly
}

bool MemberDef::hasMultiLineInitializer() const
{
  return initLines>0 && 
         ((initLines<maxInitLines && userInitLines==-1) // implicitly enabled
          || initLines<userInitLines // explicitly enabled
         );
}

void MemberDef::setInitializer(const char *initializer)    
{ 
  init=initializer; 
  int p=init.length()-1;
  while (p>=0 && isspace(init.at(p))) p--;
  init=init.left(p+1);
  initLines=init.contains('\n');
}

void MemberDef::addListReference(Definition *d)
{
  visited=TRUE;
  QCString memLabel;
  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) 
  {
    memLabel=theTranslator->trGlobal(TRUE,TRUE);
  }
  else
  {
    memLabel=theTranslator->trMember(TRUE,TRUE);
  }
  addRefItem(todoId(),testId(),bugId(),memLabel,
      d->getOutputFileBase()+":"+anchor(),name(),argsString());
}