vhdldocgen.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <qcstring.h>
#include <qfileinfo.h>
#include <qstringlist.h>
#include <qmap.h>
#include "vhdldocgen.h"
#include "message.h"
#include "config.h"
#include "doxygen.h"
#include "util.h"
#include "language.h"
#include "commentscan.h"
#include "index.h"
#include "definition.h"
#include "searchindex.h"
#include "outputlist.h"
#include "parserintf.h"
#include "layout.h"
#include "arguments.h"
#include "portable.h"
#include "memberlist.h"
#include "memberdef.h"
#include "groupdef.h"
#include "classlist.h"
#include "namespacedef.h"
#include "filename.h"
#include "membergroup.h"
#include "plantuml.h"
#include "vhdljjparser.h"
#include "VhdlParser.h"
#include "vhdlcode.h"

Go to the source code of this file.

Macros
#define	theTranslator_vhdlType   VhdlDocGen::trVhdlType
#define	STARTL
#define	DECLN
#define	STARTFIN   (FlowChart::START_NO | FlowChart::END_NO)
#define	LOOP
#define	ENDCL   (FlowChart::END_CASE | FlowChart::END_LOOP)
#define	EEND   (FlowChart::ENDIF_NO | FlowChart::ELSE_NO )
#define	IFF   (FlowChart::ELSIF_NO | FlowChart::IF_NO)
#define	EXITNEXT   (FlowChart::EXIT_NO | FlowChart::NEXT_NO )
#define	EMPTY   (EEND | FlowChart::ELSIF_NO)
#define	EE   (FlowChart::ELSE_NO | FlowChart::ELSIF_NO)
#define	EMPTNODE   (ENDCL | EEND | FlowChart::ELSIF_NO)
#define	FLOWLEN   (flowList.count()-1)

Functions
static QDict< QCString >	g_vhdlKeyDict0 (17, FALSE)
static QDict< QCString >	g_vhdlKeyDict1 (17, FALSE)
static QDict< QCString >	g_vhdlKeyDict2 (17, FALSE)
static QDict< QCString >	g_vhdlKeyDict3 (17, FALSE)
static void	initUCF (Entry *root, const char *type, QCString &qcs, int line, QCString &fileName, QCString &brief)
static void	writeUCFLink (const MemberDef *mdef, OutputList &ol)
static void	assignBinding (VhdlConfNode *conf)
static void	addInstance (ClassDef *entity, ClassDef *arch, ClassDef *inst, Entry *cur, ClassDef *archBind=NULL)
static void	createSVG ()
static void	startDot (FTextStream &t)
static void	startTable (FTextStream &t, const QCString &className)
static QList< MemberDef > *	getPorts (ClassDef *cd)
static void	writeVhdlEntityToolTip (FTextStream &t, ClassDef *cd)
static void	endDot (FTextStream &t)
static void	writeTable (QList< MemberDef > *port, FTextStream &t)
static void	endTabel (FTextStream &t)
static void	writeClassToDot (FTextStream &t, ClassDef *cd)
static void	writeVhdlDotLink (FTextStream &t, const QCString &a, const QCString &b, const QCString &style)
static void	codify (FTextStream &t, const char *str)
static void	writeLink (const MemberDef *mdef, OutputList &ol)
static void	startFonts (const QCString &q, const char *keyword, OutputList &ol)
static QCString	splitString (QCString &str, char c)
static int	compareString (const QCString &s1, const QCString &s2)
static QCString	formatBriefNote (const QCString &brief, ClassDef *cd)
static void	writeColumn (FTextStream &t, MemberDef *md, bool start)
static void	setGlobalType (MemberList *ml)
static bool	membersHaveSpecificType (MemberList *ml, uint64 type)
static MemberDef *	findMemFlow (const MemberDef *mdef)
void	alignText (QCString &q)

Variables
static const MemberDef *	flowMember =0
static QMap< QCString, MemberDef * >	varMap
static QList< ClassDef >	qli
static QMap< ClassDef *, QList< ClassDef > >	packages
static int	recordCounter =0
static QList< MemberDef >	mdList
static int	ifcounter =0
static int	nodeCounter =0
static struct { ... }	flowCol

Macro Definition Documentation

#define DECLN

Value:

(FlowChart::WHEN_NO      | \
                  FlowChart::ELSIF_NO     | FlowChart::IF_NO    | \
                  FlowChart::FOR_NO       | FlowChart::WHILE_NO | \
                  FlowChart::CASE_NO      | FlowChart::LOOP_NO )

Definition at line 3419 of file vhdldocgen.cpp.

#define EE   (FlowChart::ELSE_NO | FlowChart::ELSIF_NO)

Definition at line 3431 of file vhdldocgen.cpp.

#define EEND   (FlowChart::ENDIF_NO | FlowChart::ELSE_NO )

Definition at line 3427 of file vhdldocgen.cpp.

#define EMPTNODE   (ENDCL | EEND | FlowChart::ELSIF_NO)

Definition at line 3432 of file vhdldocgen.cpp.

#define EMPTY   (EEND | FlowChart::ELSIF_NO)

Definition at line 3430 of file vhdldocgen.cpp.

#define ENDCL   (FlowChart::END_CASE | FlowChart::END_LOOP)

Definition at line 3426 of file vhdldocgen.cpp.

#define EXITNEXT   (FlowChart::EXIT_NO | FlowChart::NEXT_NO )

Definition at line 3429 of file vhdldocgen.cpp.

#define FLOWLEN   (flowList.count()-1)

Definition at line 3433 of file vhdldocgen.cpp.

#define IFF   (FlowChart::ELSIF_NO | FlowChart::IF_NO)

Definition at line 3428 of file vhdldocgen.cpp.

#define LOOP

Value:

(FlowChart::FOR_NO       | FlowChart::WHILE_NO | \
                  FlowChart::LOOP_NO )

Definition at line 3424 of file vhdldocgen.cpp.

#define STARTFIN   (FlowChart::START_NO | FlowChart::END_NO)

Definition at line 3423 of file vhdldocgen.cpp.

#define STARTL

Value:

(FlowChart::WHILE_NO     | FlowChart::IF_NO    | \
                  FlowChart::FOR_NO       | FlowChart::CASE_NO  | \
                  FlowChart::LOOP_NO      | WHEN_NO)

Definition at line 3416 of file vhdldocgen.cpp.

#define theTranslator_vhdlType   VhdlDocGen::trVhdlType

Definition at line 64 of file vhdldocgen.cpp.

Function Documentation

static void addInstance ( ClassDef *  entity, ClassDef *  arch, ClassDef *  inst, Entry *  cur, ClassDef *  archBind = NULL  )

static

Definition at line 3107 of file vhdldocgen.cpp.

{

  QCString bName,n1;
  if (ar==0) return;

  if (classEntity==0)
  {
    //add component inst
    n1=cur->type;
    goto ferr;
  }

  if (classEntity==cd) return;

  bName=classEntity->name();
  // fprintf(stderr,"\naddInstance %s to %s %s %s\n", classEntity->name().data(),cd->name().data(),ar->name().data(),cur->name);
  n1=classEntity->name().data();

  if (!cd->isBaseClass(classEntity, true, 0))
  {
    cd->insertBaseClass(classEntity,n1,Public,Normal,0);
  }
  else
  {
    VhdlDocGen::addBaseClass(cd,classEntity);
  }

  if (!VhdlDocGen::isSubClass(classEntity,cd,true,0))
  {
    classEntity->insertSubClass(cd,Public,Normal,0);
    classEntity->setLanguage(SrcLangExt_VHDL);
  }

ferr:
  QCString uu=cur->name;
  MemberDef *md=new MemberDef(
      ar->getDefFileName(), cur->startLine,cur->startColumn,
      n1,uu,uu, 0,
      Public, Normal, cur->stat,Member,
      MemberType_Variable,
      0,
      0);

  if (ar->getOutputFileBase())
  {
    TagInfo tg;
    tg.anchor = 0;
    tg.fileName = ar->getOutputFileBase();
    tg.tagName = 0;
    md->setTagInfo(&tg);
  }

  //fprintf(stderr,"\n%s%s%s\n",md->name().data(),cur->brief.data(),cur->doc.data());

  md->setLanguage(SrcLangExt_VHDL);
  md->setMemberSpecifiers(VhdlDocGen::INSTANTIATION);
  md->setBriefDescription(cur->brief,cur->briefFile,cur->briefLine);
  md->setBodySegment(cur->startLine,-1) ;
  md->setDocumentation(cur->doc.data(),cur->docFile.data(),cur->docLine);
  FileDef *fd=ar->getFileDef();
  md->setBodyDef(fd);


  QCString info="Info: Elaborating entity "+n1;
  fd=ar->getFileDef();
  info+=" for hierarchy ";
  QRegExp epr("[|]");
  QCString label=cur->type+":"+cur->write+":"+cur->name;
  label.replace(epr,":");
  info+=label;
  fprintf(stderr,"\n[%s:%d:%s]\n",fd->fileName().data(),cur->startLine,info.data());


  ar->insertMember(md);

}

void alignText

(

QCString &

q

)

Definition at line 3468 of file vhdldocgen.cpp.

{
  if (q.length()<=80) return;

  if (q.length()>200)
  {
    q.resize(200);
  }

  q.append(" ...");

  QRegExp reg("[\\s|]");
  QCString str(q.data());
  QCString temp;

  while (str.length()>80)
  {
    int j=str.findRev(reg,80);
    if (j<=0)
    {
      temp+=str;
      q=temp;
      return;
    }
    else
    {
      QCString qcs=str.left(j);
      temp+=qcs+"\\";
      temp+="n";
      str.remove(0,j);
    }
  }//while

 q=temp+str;
// #endif
}

void assignBinding ( VhdlConfNode *  conf )

static

Definition at line 2918 of file vhdldocgen.cpp.

{
  QList<Entry> instList=getVhdlInstList();
  QListIterator<Entry> eli(instList);
  Entry *cur=0;
  ClassDef *archClass=0,*entClass=0;
  QCString archName;
  QCString arcBind,entBind;

  bool others,all;
  entBind=conf->binding;
  QCString conf2=VhdlDocGen::parseForBinding(entBind,arcBind);

  if (qstricmp(conf2,"configuration")==0)
  {
    QList<VhdlConfNode> confList =  getVhdlConfiguration();
    VhdlConfNode* vconf;
    //  bool found=false;
    for (uint iter=0;iter<confList.count(); iter++)
    {
      vconf= (VhdlConfNode *)confList.at(iter);
      QCString n=VhdlDocGen::getIndexWord(vconf->confVhdl.data(),0);
      if (n==entBind)
      {
        // found=true;
        entBind=VhdlDocGen::getIndexWord(vconf->confVhdl.data(),1);
        QCString a=VhdlDocGen::getIndexWord(conf->compSpec.data(),0);
        QCString e=VhdlDocGen::getIndexWord(conf->confVhdl.data(),1);
        a=e+"::"+a;
        archClass= VhdlDocGen::findVhdlClass(a.data());//Doxygen::classSDict->find(a.data());
        entClass= VhdlDocGen::findVhdlClass(e.data());//Doxygen::classSDict->find(e.data());
        break;
      }
    }
  }
  else  // conf2!=configuration
  {
    QCString a,c,e;
    if (conf->isInlineConf)
    {
      c=conf->confVhdl;
      e=VhdlDocGen::getIndexWord(conf->confVhdl.data(),0);
    }
    else
    {
      a=VhdlDocGen::getIndexWord(conf->compSpec.data(),0);
      e=VhdlDocGen::getIndexWord(conf->confVhdl.data(),1);
      c=e+"::"+a;
    }
    archClass= VhdlDocGen::findVhdlClass(c.data());//Doxygen::classSDict->find(a.data());
    entClass= VhdlDocGen::findVhdlClass(e.data()); //Doxygen::classSDict->find(e.data());
  }

  QCString label=conf->compSpec.lower();
  //label.prepend("|");

  if (!archClass)
  {
 //   err("architecture %s not found ! ",conf->confVhdl.data());
    return;
  }

  archName=archClass->name();
  QCString allOt=VhdlDocGen::getIndexWord(conf->arch.data(),0);
  all=allOt.lower()=="all" ;
  others= allOt.lower()=="others";

  for (;(cur=eli.current());++eli)
  {
    if (cur->exception.lower()==label || conf->isInlineConf)
    {
      QCString archy;

      if (all || others)
      {
        archy=VhdlDocGen::getIndexWord(conf->arch.data(),1);
      }
      else
      {
        archy=conf->arch;
      }

      QCString    inst1=VhdlDocGen::getIndexWord(archy.data(),0).lower();
      QCString    comp=VhdlDocGen::getIndexWord(archy.data(),1).lower();

      QStringList ql=QStringList::split(",",inst1);

      for (uint j=0;j<ql.count();j++)
      {
        QCString archy1,sign1;
        if (all || others)
        {
          archy1=VhdlDocGen::getIndexWord(conf->arch.data(),1);
          sign1=cur->type;
        }
        else
        {
          archy1=comp+":"+ql[j].utf8();
          sign1=cur->type+":"+cur->name;
        }

        if (archy1==sign1.lower() && !cur->stat)
        {
          // fprintf(stderr," \n label [%s] [%s] [%s]",cur->exception.data(),cur->type.data(),cur->name.data());
          ClassDef *ent= VhdlDocGen::findVhdlClass(entBind.data());//Doxygen::classSDict->find(entBind.data());

          if (entClass==0 || ent==0)
          {
            continue;
          }

          addInstance(ent,archClass,entClass,cur);
          cur->stat=TRUE;
          break;
        }
      }// for
    }
  }//for each element in instList

}//assignBinding

static void codify ( FTextStream &  t, const char *  str  )

static

Definition at line 103 of file vhdldocgen.cpp.

{
  if (str)
  {
    const char *p=str;
    char c;
    while (*p)
    {
      c=*p++;
      switch(c)
      {
        case '<':  t << "&lt;";
                   break;
        case '>':  t << "&gt;";
                   break;
        case '&':  t << "&amp;";
                   break;
        case '\'': t << "&#39;";
                   break;
        case '"':  t << "&quot;";
                   break;
        default:   t << c;
                   break;
      }
    }
  }
}

static int compareString ( const QCString &  s1, const QCString &  s2  )

static

Definition at line 158 of file vhdldocgen.cpp.

{
  return qstricmp(s1.stripWhiteSpace(),s2.stripWhiteSpace());
}

static void createSVG ( )

static

Definition at line 163 of file vhdldocgen.cpp.

{
    QCString ov =Config_getString("HTML_OUTPUT");
    QCString dir="-o \""+ov+"/vhdl_design_overview.html\"";
    ov+="/vhdl_design.dot";

    QCString vlargs="-Tsvg \""+ov+"\" "+dir ;

    if (portable_system("dot",vlargs)!=0)
    {
      err("could not create dot file");
    }
}

static void endDot ( FTextStream &  t )

static

Definition at line 270 of file vhdldocgen.cpp.

{
  t <<" } \n";
}

static void endTabel ( FTextStream &  t )

static

Definition at line 450 of file vhdldocgen.cpp.

{
  t << "</TABLE>>\n";
  t << "] \n";
}

static MemberDef* findMemFlow ( const MemberDef *  mdef )

static

Definition at line 3305 of file vhdldocgen.cpp.

{
  for(uint j=0;j<mdList.count();j++)
  {
    MemberDef* md=(MemberDef*)mdList.at(j);
    if (md->name()==mdef->name() &&  md->getStartBodyLine()==mdef->getStartBodyLine())
      return md;
  }
  return 0;
}

static QCString formatBriefNote ( const QCString &  brief, ClassDef *  cd  )

static

Definition at line 293 of file vhdldocgen.cpp.

{
  QRegExp ep("[\n]");
  QCString vForm;
  QCString repl("<BR ALIGN=\"LEFT\"/>");
  QCString file=cd->getDefFileName();

  int k=cd->briefLine();

  QStringList qsl=QStringList::split(ep,brief);
  for(uint j=0;j<qsl.count();j++)
  {
    QCString qcs=qsl[j].data();
    vForm+=parseCommentAsText(cd,NULL,qcs,file,k);
    k++;
    vForm+='\n';
  }

  vForm.replace(ep,repl.data());
  return vForm;
}

static QDict<QCString> g_vhdlKeyDict0 ( 17  , FALSE    )

static

static QDict<QCString> g_vhdlKeyDict1 ( 17  , FALSE    )

static

static QDict<QCString> g_vhdlKeyDict2 ( 17  , FALSE    )

static

static QDict<QCString> g_vhdlKeyDict3 ( 17  , FALSE    )

static

static QList< MemberDef > * getPorts ( ClassDef *  cd )

static

Definition at line 470 of file vhdldocgen.cpp.

{
  MemberDef* md;
  QList<MemberDef> *portList=new QList<MemberDef>;
  MemberList *ml=cd->getMemberList(MemberListType_variableMembers);

  if (ml==0)
  {
    delete portList;
    return 0;
  }

  MemberListIterator fmni(*ml);

  for (fmni.toFirst();(md=fmni.current());++fmni)
  {
    if (md->getMemberSpecifiers()==VhdlDocGen::PORT)
    {
      portList->append(md);
    }
  }

  return portList;
}

static void initUCF ( Entry *  root, const char *  type, QCString &  qcs, int  line, QCString &  fileName, QCString &  brief  )

static

Definition at line 2709 of file vhdldocgen.cpp.

{
  if (qcs.isEmpty())return;
  QRegExp reg("[\\s=]");
  QCString n;
  // bool bo=(qstricmp(type,qcs.data())==0);

  VhdlDocGen::deleteAllChars(qcs,';');
  qcs=qcs.stripWhiteSpace();

  int i= qcs.find(reg);
  if (i<0) return;
  if (i==0)
  {
    n=type;
    VhdlDocGen::deleteAllChars(n,'#');
    type="";
  }
  else
  {
    n=qcs.left(i);
  }
  qcs=qcs.remove(0,i+1);
  //  qcs.prepend("|");

  qcs.stripPrefix("=");

  Entry* current=new Entry;
  current->spec=VhdlDocGen::UCF_CONST;
  current->section=Entry::VARIABLE_SEC;
  current->bodyLine=line;
  current->fileName=fileName;
  current->type="ucf_const";
  current->args+=qcs;
  current->lang=  SrcLangExt_VHDL ;

  // adding dummy name for constraints like VOLTAGE=5,TEMPERATURE=20 C
  if (n.isEmpty())
  {
    n="dummy";
    n+=VhdlDocGen::getRecordNumber();
  }

  current->name= n+"_";
  current->name.append(VhdlDocGen::getRecordNumber().data());

  if (!brief.isEmpty())
  {
    current->brief=brief;
    current->briefLine=line;
    current->briefFile=fileName;
    brief.resize(0);
  }

  root->addSubEntry(current);
}

static bool membersHaveSpecificType ( MemberList *  ml, uint64  type  )

static

Definition at line 2330 of file vhdldocgen.cpp.

{
  if (ml==0) return FALSE;
  MemberDef *mdd=0;
  MemberListIterator mmli(*ml);
  for ( ; (mdd=mmli.current()); ++mmli )
  {
    if (mdd->getMemberSpecifiers()==type) //is type in class
    {
      return TRUE;
    }
  }
  if (ml->getMemberGroupList())
  {
    MemberGroupListIterator mgli(*ml->getMemberGroupList());
    MemberGroup *mg;
    while ((mg=mgli.current()))
    {
      if (mg->members())
      {
        if (membersHaveSpecificType(mg->members(),type)) return TRUE;
      }
      ++mgli;
    }
  }
  return FALSE;
}

static void setGlobalType ( MemberList *  ml )

static

Definition at line 1801 of file vhdldocgen.cpp.

{
  if (ml==0) return;
  MemberDef *mdd=0;
  MemberListIterator mmli(*ml);
  for ( ; (mdd=mmli.current()); ++mmli )
  {
    if (qstrcmp(mdd->argsString(),"package")==0)
    {
        mdd->setMemberSpecifiers(VhdlDocGen::INSTANTIATION);
    }
    else if (qstrcmp(mdd->argsString(),"configuration")==0)
    {
      mdd->setMemberSpecifiers(VhdlDocGen::CONFIG);
    }
    else if (qstrcmp(mdd->typeString(),"library")==0)
    {
      mdd->setMemberSpecifiers(VhdlDocGen::LIBRARY);
    }
    else if (qstrcmp(mdd->typeString(),"use")==0)
    {
      mdd->setMemberSpecifiers(VhdlDocGen::USE);
    }
    else if (qstricmp(mdd->typeString(),"misc")==0)
    {
      mdd->setMemberSpecifiers(VhdlDocGen::MISCELLANEOUS);
    }
    else if (qstricmp(mdd->typeString(),"ucf_const")==0)
    {
      mdd->setMemberSpecifiers(VhdlDocGen::UCF_CONST);
    }
  }
}

static QCString splitString ( QCString &  str, char  c  )

static

Definition at line 146 of file vhdldocgen.cpp.

{
  QCString n=str;
  int i=str.find(c);
  if (i>0)
  {
    n=str.left(i);
    str=str.remove(0,i+1);
  }
  return n;
}

static void startDot ( FTextStream &  t )

static

Definition at line 262 of file vhdldocgen.cpp.

{
  t << " digraph G { \n";
  t << "rankdir=LR \n";
  t << "concentrate=TRUE\n";
  t << "stylesheet=\"doxygen.css\"\n";
}

static void startFonts ( const QCString &  q, const char *  keyword, OutputList &  ol  )

static

Definition at line 139 of file vhdldocgen.cpp.

{
  ol.startFontClass(keyword);
  ol.docify(q.data());
  ol.endFontClass();
}

static void startTable ( FTextStream &  t, const QCString &  className  )

static

Definition at line 275 of file vhdldocgen.cpp.

{
  t << className <<" [ shape=none , fontname=\"arial\",  fontcolor=\"blue\" , \n";
  t << "label=<<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">\n";
}

static void writeClassToDot ( FTextStream &  t, ClassDef *  cd  )

static

Definition at line 456 of file vhdldocgen.cpp.

{
  t << "<TR><TD COLSPAN=\"2\" BGCOLOR=\"yellow\" ";
  t << "PORT=\"";
  t << cd->name();
  t << "\" ";
  t << "href=\"";
  t << cd->getOutputFileBase() << Doxygen::htmlFileExtension;
  t << "\" ";
  t << ">";
  t << cd->name();
  t << " </TD></TR>\n";
}

static void writeColumn ( FTextStream &  t, MemberDef *  md, bool  start  )

static

Definition at line 364 of file vhdldocgen.cpp.

{
  QCString toolTip;

  static QRegExp reg("[%]");
  bool bidir=(md!=0 &&( qstricmp(md->typeString(),"inout")==0));

  if (md)
  {
    toolTip=md->briefDescriptionAsTooltip();
    if (!toolTip.isEmpty())
    {
      QCString largs = md->argsString();
      if (!largs.isEmpty())
        largs=largs.replace(reg," ");
      toolTip+=" [";
      toolTip+=largs;
      toolTip+="]";
    }
  }
  if (start)
  {
    t <<"<TR>\n";
  }

  t << "<TD ALIGN=\"LEFT\" ";
  if (md)
  {
    t << "href=\"";
    t << md->getOutputFileBase()<< Doxygen::htmlFileExtension;
    t << "#" << md->anchor();
    t<<"\" ";

    t<<" TOOLTIP=\"";
    if (!toolTip.isEmpty())
    {
      codify(t,toolTip.data());
    }
    else
    {
      QCString largs = md->argsString();
      if (!largs.isEmpty())
      {
        largs=largs.replace(reg," ");
        codify(t,largs.data());
      }
    }
    t << "\" ";

    t << " PORT=\"";
    t << md->name();
    t << "\" ";
  }
  if (!toolTip.isEmpty())
  {
    // if (!toolTip.isEmpty())

    if (bidir)
      t << "BGCOLOR=\"orange\">";
    else
      t << "BGCOLOR=\"azure\">";
  }
  else if (bidir)
  {
    t << "BGCOLOR=\"pink\">";
  }
  else
  {
    t << "BGCOLOR=\"lightgrey\">";
  }
  if (md)
  {
    t << md->name();
  }
  else
  {
    t << " \n";
  }
  t << "</TD>\n";

  if (!start)
  {
    t << "</TR>\n";
  }
}

static void writeLink ( const MemberDef *  mdef, OutputList &  ol  )

static

Definition at line 131 of file vhdldocgen.cpp.

{
  ol.writeObjectLink(mdef->getReference(),
      mdef->getOutputFileBase(),
      mdef->anchor(),
      mdef->name());
}

static void writeTable ( QList< MemberDef > *  port, FTextStream &  t  )

static

Definition at line 497 of file vhdldocgen.cpp.

{
  MemberDef *md;
  uint len=port->count();

  QList<MemberDef> inPorts;
  QList<MemberDef> outPorts;

  uint j;
  for (j=0;j<len;j++)
  {
    md=(MemberDef*)port->at(j);
    QCString qc=md->typeString();
    if(qc=="in")
    {
      inPorts.append(md);
    }
    else
    {
      outPorts.append(md);
    }
  }

  int inp  = inPorts.count();
  int outp = outPorts.count();
  int maxLen;

  if (inp>=outp)
  {
    maxLen=inp;
  }
  else
  {
    maxLen=outp;
  }

  int i;
  for(i=0;i<maxLen;i++)
  {
    //write inports
    if (i<inp)
    {
      md=(MemberDef*)inPorts.at(i);
      writeColumn(t,md,TRUE);
    }
    else
    {
      writeColumn(t,NULL,TRUE);
    }

    if (i<outp)
    {
      md=(MemberDef*)outPorts.at(i);
      writeColumn(t,md,FALSE);
    }
    else
    {
      writeColumn(t,NULL,FALSE);
    }
  }
}

static void writeUCFLink ( const MemberDef *  mdef, OutputList &  ol  )

static

Definition at line 2767 of file vhdldocgen.cpp.

{

  QCString largs(mdef->argsString());
  QCString n= splitString(largs, '#');
  // VhdlDocGen::adjustRecordMember(mdef);
  bool equ=(n.length()==largs.length());

  if (!equ)
  {
    ol.writeString(n.data());
    ol.docify(" ");
    ol.insertMemberAlign();
  }

  if (mdef->name().contains("dummy")==0)
  {
    writeLink(mdef,ol);
  }
  if (equ)
  {
    ol.insertMemberAlign();
  }
  ol.docify(" ");
  VhdlDocGen::formatString(largs,ol,mdef);
}

static void writeVhdlDotLink ( FTextStream &  t, const QCString &  a, const QCString &  b, const QCString &  style  )

static

Definition at line 281 of file vhdldocgen.cpp.

{
  t << a << "->" << b;
  if (!style.isEmpty())
  {
    t << "[style=" << style << "];\n";
  }
  t << "\n";
}

static void writeVhdlEntityToolTip ( FTextStream &  t, ClassDef *  cd  )

static

Definition at line 343 of file vhdldocgen.cpp.

{

  QCString brief=cd->briefDescription();

  if (brief.isEmpty()) return;

  brief=formatBriefNote(brief,cd);

  QCString node="node";
  node+=VhdlDocGen::getRecordNumber();
  t << node <<"[shape=none margin=0.1, label=<\n";
  t << "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"2\" >\n ";
  t << "<TR><TD BGCOLOR=\"lightcyan\"> ";
  t << brief;
  t << " </TD></TR></TABLE>>];";
  QCString dotn=cd->name()+":";
  dotn+=cd->name();
  writeVhdlDotLink(t,dotn,node,"dotted");
}

Variable Documentation

struct { ... } flowCol

Initial value:

=
{ "green",       
  "red",         
  "black",       
  "khaki",       
  "0.7 0.3 1.0", 
  "lightyellow", 
  "white",       
  "lightcyan"    
}

const MemberDef* flowMember =0

static

Definition at line 88 of file vhdldocgen.cpp.

int ifcounter =0

static

Definition at line 3435 of file vhdldocgen.cpp.

QList<MemberDef> mdList

static

Definition at line 3303 of file vhdldocgen.cpp.

int nodeCounter =0

static

Definition at line 3436 of file vhdldocgen.cpp.

QMap<ClassDef*,QList<ClassDef> > packages

static

Definition at line 715 of file vhdldocgen.cpp.

QList<ClassDef> qli

static

Definition at line 714 of file vhdldocgen.cpp.

int recordCounter =0

static

Definition at line 1308 of file vhdldocgen.cpp.

QMap<QCString,MemberDef*> varMap

static

Definition at line 713 of file vhdldocgen.cpp.