Release-1.5.4-20080101

1 files changed, 2319 insertions, 0 deletions

diff --git a/src/vhdldocgen.cpp b/src/vhdldocgen.cpp
new file mode 100644
index 0000000..60a49b1
--- /dev/null
+++ b/src/vhdldocgen.cpp
@@ -0,0 +1,2319 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2008 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.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+/******************************************************************************
+ * Parser for VHDL subset
+ * written by M. Kreis
+ * supports VHDL-87
+ * does not support all keywords of VHDL '93 (impure function/shared variables ..)
+ * and VHDL-AMS 
+ ******************************************************************************/
+
+// global includes
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <qcstring.h>
+#include <qfileinfo.h>
+#include <qstringlist.h>
+
+/* --------------------------------------------------------------- */
+
+// local includes
+#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"
+
+/* --------------------------------------------------------------- */
+
+//#define theTranslator_vhdlType theTranslator->trVhdlType
+#define theTranslator_vhdlType VhdlDocGen::trVhdlType
+
+static QDict<QCString> g_vhdlKeyDict0(17,FALSE); 
+static QDict<QCString> g_vhdlKeyDict1(17,FALSE); 
+static QDict<QCString> g_vhdlKeyDict2(17,FALSE);
+
+static  QCString g_vhdlkeyword("vhdlkeyword");
+static  QCString g_vhdltype("comment");
+static  QCString g_vhdllogic("vhdllogic");
+
+// keywords
+static const char* g_vhdlKeyWordMap0[] = 
+{ 
+  "std","ieee","work","standard","textio","std_logic_1164",
+  "std_logic_arith","std_logic_misc","std_logic_signed","std_logic_textio",
+  "std_logic_unsigned","numeric_bit","numeric_std","math_complex","math_real",
+  "vital_primitives","vital_timing","severity_level","time","delay_length",
+  "natural", "positive", "bit_vector","file_open_kind","file_open_status",
+  "line","text","side", "width","event","rising_edge", "falling_edge",
+  "access","after","alias", "all","architecture","array", "assert","attribute",
+  "begin","block","body", "buffer", "bus", "case", "component", "configuration", 
+  "constant", "disconnect", "downto", "else", "elsif", "end", "entity", "exit",
+  "file", "for", "function", "generate", "generic", "group", "guarded", "if", 
+  "impure", "in", "inertial", "inout", "is","label", "library", "linkage", 
+  "literal", "loop","map", "new", "next", "null", "of", "on", "open", "others", 
+  "out", "package", "port", "postponed", "procedure", "process", "pure",
+  "range", "record", "register", "reject", "report", "return","select", 
+  "severity", "shared", "signal", "subtype", "then", "to", "transport", 
+  "type","unaffected", "units", "until", "use","variable", "wait", "when", 
+  "while", "with",0
+};
+
+// type
+static const char* g_vhdlKeyWordMap1[] = 
+{ 
+  "natural","unsigned","signed","string","boolean", "bit","character",
+  "std_ulogic","std_ulogic_vector","sTd_logic","std_logic_vector","integer",
+  "real","zzz",0
+};
+
+// logic
+static const char* g_vhdlKeyWordMap2[] = 
+{
+  "abs","and","or","not","mod", "xor","rem","xnor","ror","rol","sla",
+  "sll",0
+};
+
+VhdlDocGen::VhdlDocGen()
+{
+}
+
+VhdlDocGen::~VhdlDocGen()
+{
+}
+
+void VhdlDocGen::init()
+{
+  int j=0;
+  g_vhdlKeyDict0.setAutoDelete(TRUE);
+  g_vhdlKeyDict1.setAutoDelete(TRUE);
+  g_vhdlKeyDict2.setAutoDelete(TRUE);
+
+  j=0;
+  while (g_vhdlKeyWordMap0[j])
+  {
+    g_vhdlKeyDict0.insert(g_vhdlKeyWordMap0[j],
+	               new QCString(g_vhdlKeyWordMap0[j]));
+    j++;
+  }
+
+  j=0;
+  while (g_vhdlKeyWordMap1[j])
+  {
+    g_vhdlKeyDict1.insert(g_vhdlKeyWordMap1[j],
+	               new QCString(g_vhdlKeyWordMap1[j]));
+    j++;
+  }
+
+  j=0;
+  while (g_vhdlKeyWordMap2[j])
+  {
+    g_vhdlKeyDict2.insert(g_vhdlKeyWordMap2[j],
+	               new QCString(g_vhdlKeyWordMap2[j]));
+    j++;
+  }
+
+}// buildKeyMap
+
+/*!
+ * returns the color of a keyword 
+ */ 
+
+QCString* VhdlDocGen::findKeyWord(const QCString& word)
+{
+  if (word.isEmpty() || word.at(0)=='\0') return 0;
+  //printf("VhdlDocGen::findKeyWord(%s)\n",word.data());
+
+  if (g_vhdlKeyDict0.find(word))
+    return &g_vhdlkeyword;
+
+  if (g_vhdlKeyDict1.find(word))
+    return &g_vhdltype;
+
+  if (g_vhdlKeyDict2.find(word))
+    return &g_vhdllogic;
+
+  return 0;
+}
+
+/*!
+ * returns the parsed entry at line xxx
+ */
+
+Entry* VhdlDocGen::getEntryAtLine(const Entry* ce,int line)
+{
+  EntryListIterator eli(*ce->children());
+  Entry *found=0;
+  Entry *rt;
+  for (;(rt=eli.current());++eli)
+  {
+    if (rt->bodyLine==line)
+    {
+      found=rt;
+    } // if
+    if (!found) 
+    {
+      found=getEntryAtLine(rt,line);
+    }
+  }
+  return found;
+}// getEntryAtLine
+
+void VhdlDocGen::debugClassName(ClassSDict* mDict)
+{
+  // for each class
+  ClassSDict::Iterator cli(*mDict);
+  ClassDef *cd;
+  for ( ; (cd=cli.current()) ; ++cli )
+  {
+    printf("\n -------------------------class----------------------------------------\n");
+
+    QCString nnn=cd->className();
+    QCString qref=cd->getReference();
+    QCString outBase=cd->getOutputFileBase();
+    QCString fileBase=cd->getFileBase();
+    QCString compType=cd->compoundTypeString();
+    QCString inDoc=cd->documentation();//->inbodyDocumentation();
+    printf("\n refernz [%p]",cd);
+    printf("\n compType [%s]",compType.data());
+    printf("\n Name [%s]",nnn.data());
+    printf("\n TYPE[%d ",cd->definitionType());
+    printf("\n Ref [%s] ",qref.data());
+    printf("\n OutBase [%s] fileBase [%s]",outBase.data(),fileBase.data());
+
+    printf("\n -------------------------------------------------------------------\n");
+
+  }// for
+}// Debug Class Name
+
+
+bool found =FALSE;
+static Entry eMerge;
+
+ClassDef *VhdlDocGen::getClass(const char *name)
+{
+  if (name==0 || name[0]=='\0') return 0;
+
+  ClassDef *cd=0;   
+  QCString temp(name);
+  //temp=temp.lower();
+  temp=temp.stripWhiteSpace();
+  cd= Doxygen::classSDict->find(temp.data());
+  return cd;
+}
+
+/*!
+ * adds components to their entities
+ */
+void VhdlDocGen::computeVhdlComponentRelations(const QDict<EntryNav>& classEntries,FileStorage* g_storage)
+{
+  ClassSDict::Iterator cli(*Doxygen::classSDict);
+  for (cli.toFirst();cli.current();++cli) cli.current()->visited=FALSE;
+  QDictIterator<EntryNav> edi(classEntries);
+  EntryNav *rootNav;
+  for (;(rootNav=edi.current());++edi)
+  {
+    ClassDef *cd;
+    rootNav->loadEntry(g_storage);
+    Entry *root = rootNav->entry();
+    QCString bName=stripAnonymousNamespaceScope(rootNav->name());
+    if ((cd=getClass(bName)))
+    {
+      QListIterator<BaseInfo> bii(*root->extends);
+      BaseInfo *bi=0;
+      for (bii.toFirst();(bi=bii.current());++bii)
+      {
+	ClassDef* baseDef=getClass(bi->name);
+
+	if (baseDef && baseDef != cd)
+	{
+	  QCString cc=VhdlDocGen::getClassName(cd);
+	  ClassDef *ccdef=getClass(cc);
+	  if (ccdef==0) break;
+
+	  int ii=ccdef->protection();
+	  int jj=baseDef->protection();
+
+	  if (ii==VhdlDocGen::ENTITYCLASS && jj==VhdlDocGen::ENTITYCLASS && (ccdef !=baseDef))
+	  {
+	    ccdef->insertBaseClass(baseDef,bi->name,Public,Normal,0);
+	    baseDef->insertSubClass(ccdef,Public,bi->virt,0);
+	  }        
+	}
+	else 
+	{
+	  if (Config_getBool("WARNINGS"))
+	    warn(rootNav->fileDef()->fileName().data(),root->startLine, "found component without entity: [%s]",bi->name.data());
+	}
+      }//for 
+    }//if
+    rootNav->releaseEntry();
+  }// for
+} // computeVhdlComponentRelations
+
+
+/*
+ * returns a reference, if one class [package(body),entity or an architecture is found]
+ */
+
+ClassDef* VhdlDocGen::findComponent(int type)
+{
+  ClassSDict::Iterator cli(*Doxygen::classSDict);
+  ClassDef *cd=0;
+
+  for ( ; (cd=cli.current()) ; ++cli )
+  {
+    if (cd->protection()==type)
+      return cd;
+  }
+  return cd;
+}
+
+ClassDef* VhdlDocGen::getPackageName(const QCString & name)
+{
+  ClassDef* cd=0;
+  QStringList ql=QStringList::split(".",name,FALSE);
+  cd=getClass(name);
+
+  return cd;
+}
+
+MemberDef* VhdlDocGen::findMember(const QCString& className, const QCString& memName)
+{
+  QDict<QCString> packages(17,FALSE);   
+  packages.setAutoDelete(TRUE);
+  ClassDef* cd;
+  MemberDef *mdef=0;
+
+  cd=getClass(className);
+  //printf("VhdlDocGen::findMember(%s,%s)=%p\n",className.data(),memName.data(),cd);
+  if (cd==0) return 0;
+
+  mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::variableMembers);
+  if (mdef) return mdef;
+  mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::pubMethods);
+  if (mdef) return mdef;
+
+  // nothing found so far 
+  // if we are an architecture or package body search in entitiy
+
+  if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ARCHITECTURECLASS || 
+      (VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)
+  {
+    Definition *d = cd->getOuterScope();
+    if (d && d->definitionType()==Definition::TypeClass)
+    {
+      ClassDef *ecd = (ClassDef*)d;
+      mdef=VhdlDocGen::findMemberDef(ecd,memName,MemberList::variableMembers);
+      if (mdef) return mdef;
+    }
+    //cd=getClass(getClassName(cd));
+    //if (!cd) return 0;
+  }
+  // nothing found , so we are now searching all included packages 
+  VhdlDocGen::findAllPackages(className,packages);
+  //cd=getClass(className.data());
+  if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ARCHITECTURECLASS || 
+      (VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)
+  {
+    //QCString tempClass=getClassName(cd);
+    Definition *d = cd->getOuterScope();
+    if (d && d->definitionType()==Definition::TypeClass)
+    {
+      ClassDef *ecd = (ClassDef*)d;
+      VhdlDocGen::findAllPackages(ecd->className(),packages); 
+    }
+  }
+
+  QDictIterator<QCString> packli(packages);
+  QCString *curString;
+  for (packli.toFirst();(curString=packli.current());++packli)
+  {
+    if (curString)
+    {
+      cd=VhdlDocGen::getPackageName(*curString);
+    }
+    if (cd)
+    {    
+      mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::variableMembers);
+      if (mdef)  return mdef;
+      mdef=VhdlDocGen::findMemberDef(cd,memName,MemberList::pubMethods);
+      if (mdef) return mdef;
+    }
+  } // for
+  return 0;
+}//findMember
+
+/**
+ *  This function returns the entity|package
+ *  in which the key (type) is found
+ */
+
+MemberDef* VhdlDocGen::findMemberDef(ClassDef* cd,const QCString& key,MemberList::ListType type)
+{
+  //    return cd->getMemberByName(key);//does not work 
+  MemberDef *md=0;
+
+  MemberList *ml=    cd->getMemberList(type);
+  if (ml==0) return 0;
+
+  MemberListIterator fmni(*ml);
+
+  for (fmni.toFirst();(md=fmni.current());++fmni)
+  {
+    if (stricmp(key.data(),md->name().data())==0)
+      return md;
+  } 
+  return 0;
+}//findMemberDef
+
+/*!
+ * finds all included packages of an Entity or Package
+ */
+
+void VhdlDocGen::findAllPackages(const QCString& className,QDict<QCString>& qdict)
+{
+  ClassDef *cdef=getClass(className);
+  if (cdef)
+  {
+    MemberList *mem=cdef->getMemberList(MemberList::variableMembers); 
+    MemberDef *md;
+
+    if (mem)
+    {
+      MemberListIterator fmni(*mem);
+      for (fmni.toFirst();(md=fmni.current());++fmni)
+      {
+	if (VhdlDocGen::isPackage(md))
+	{
+	  QCString *temp1=new QCString(md->name().data());
+	  //*temp1=temp1->lower();
+	  QCString p(md->name().data());
+	  //p=p.lower();
+	  ClassDef* cd=VhdlDocGen::getPackageName(*temp1);
+	  if (cd) 
+	  { 
+	    QCString *ss=qdict.find(*temp1);
+	    if (ss==0)
+	    {
+	      qdict.insert(p,temp1);
+	      QCString tmp=cd->className();
+	      VhdlDocGen::findAllPackages(tmp,qdict);
+	    }
+	    else delete temp1;
+	  }
+	  else delete temp1;
+	}
+      }//for
+    }//if
+  }//cdef
+}// findAllPackages
+
+/*!
+ * returns the function with the matching argument list
+ * is called in vhdlcode.l
+ */
+
+MemberDef* VhdlDocGen::findFunction(const QList<Argument> &ql,
+                                    const QCString& funcname,
+				    const QCString& package, bool type)
+{
+  MemberDef* mdef=0;
+  int funcType;
+  ClassDef *cdef=getClass(package.data());
+  if (cdef==0) return 0;
+
+  if (type)
+    funcType=VhdlDocGen::PROCEDURE;
+  else
+    funcType=VhdlDocGen::FUNCTION;
+
+  MemberList *mem=cdef->getMemberList(MemberList::pubMethods); 
+
+  if (mem)
+  {
+    MemberListIterator fmni(*mem);
+    for (fmni.toFirst();(mdef=fmni.current());++fmni)
+    {
+      QCString mname=mdef->name();
+      if ((VhdlDocGen::isProcedure(mdef) || VhdlDocGen::isVhdlFunction(mdef)) && (VhdlDocGen::compareString(funcname,mname)==0))
+      {
+	LockingPtr<ArgumentList> alp = mdef->argumentList();
+
+	//  ArgumentList* arg2=mdef->getArgumentList();
+	if (alp==0) break;
+	ArgumentListIterator ali(*alp.pointer());
+	ArgumentListIterator ali1(ql);
+
+	if (ali.count() != ali1.count()) break;
+
+	Argument *arg,*arg1;
+	int equ=0;
+
+	for (;(arg=ali.current());++ali)
+	{
+	  arg1=ali1.current(); ++ali1;
+	  equ+=abs(VhdlDocGen::compareString(arg->type,arg1->type));
+
+	  QCString s1=arg->type;
+	  QCString s2=arg1->type;
+	  VhdlDocGen::deleteAllChars(s1,' ');
+	  VhdlDocGen::deleteAllChars(s2,' ');
+	  equ+=abs(VhdlDocGen::compareString(s1,s2));
+	  s1=arg->attrib;
+	  s2=arg1->attrib;
+	  VhdlDocGen::deleteAllChars(s1,' ');
+	  VhdlDocGen::deleteAllChars(s2,' ');
+	  equ+=abs(VhdlDocGen::compareString(s1,s2));
+	  // printf("\n 1. type [%s] name [%s] attrib [%s]",arg->type,arg->name,arg->attrib);
+	  // printf("\n 2. type [%s] name [%s] attrib [%s]",arg1->type,arg1->name,arg1->attrib);
+	} // for
+	if (equ==0) return mdef;
+      }//if
+    }//for       
+  }//if 
+  return mdef;
+} //findFunction
+
+/*!
+ * returns the function with the matching argument list
+ * is called in vhdscan.l
+ */
+
+Entry* VhdlDocGen::findFunction( Entry* root, Entry* func)
+{
+  //bool found=FALSE;
+  Entry *found=0;
+  int functype=func->spec;
+  EntryListIterator eli(*root->children());
+  Entry *rt;
+  for (;(rt=eli.current());++eli)
+  { 
+    if (rt->spec==functype && VhdlDocGen::compareString(rt->name,func->name)==0 && rt!=func )
+    {
+      if (VhdlDocGen::compareArgList(func->argList,rt->argList))
+      {
+	found=rt;
+	return found;
+      }
+    }//if1
+    if (!found)  
+    {
+      found = VhdlDocGen::findFunction(rt,func);
+    }
+  } // for
+  return found;
+}// findFunction
+
+/*
+ * compares two argument list of a fuction|procedure
+ */ 
+
+bool VhdlDocGen::compareArgList(ArgumentList* l1,ArgumentList* l2)
+{
+  if (l1== 0 || l2== 0) return FALSE;
+
+  ArgumentListIterator ali(*l1);
+  ArgumentListIterator ali1(*l2);
+
+  if (ali.count() != ali1.count()) return FALSE; 
+
+  Argument *arg,*arg1;
+  int equ=0;
+
+  for (;(arg=ali.current());++ali) 
+  {
+    bool found = FALSE;
+    for (ali1.toFirst();(arg1=ali1.current());++ali1) 
+    {
+      equ=0;  
+      QCString s1=arg->type;
+      QCString s2=arg1->type;
+      VhdlDocGen::deleteAllChars(s1,' '); // remove whitespaces
+      VhdlDocGen::deleteAllChars(s2,' ');
+      equ+=abs(VhdlDocGen::compareString(s1,s2));
+      s1=arg->attrib;
+      s2=arg1->attrib;
+      VhdlDocGen::deleteAllChars(s1,' ');
+      VhdlDocGen::deleteAllChars(s2,' ');        
+      equ+=abs(VhdlDocGen::compareString(s1,s2));
+      if (equ==0) found=TRUE;
+    }
+    if (!found) return FALSE;
+  }
+  return TRUE;
+}// compareArgList
+
+/*
+ * finds a matching prototype for a function description  
+ */ 
+
+Entry* VhdlDocGen::findFunction(Entry* func)
+{
+  ClassSDict::Iterator cli(*Doxygen::classSDict);
+  ClassDef *cd;
+  for (;(cd=cli.current());++cli) 
+  {
+    MemberList *mf = cd->getMemberList (MemberList::pubMethods);
+    if (mf) 
+    {
+      MemberListIterator fmni(*mf);
+      MemberDef *mdd;
+      for (fmni.toFirst();(mdd=fmni.current());++fmni)
+      {
+	int type=mdd->getMemberSpecifiers();
+	if (type==VhdlDocGen::PROCEDURE || type==VhdlDocGen::FUNCTION)
+	{
+	  QCString nnk=mdd->name();
+	  QCString ff=func->name;
+
+	  if (stricmp(mdd->name(),ff.data())==0) 
+	  {
+	    LockingPtr< ArgumentList > lp=mdd->argumentList();
+	    ArgumentList *l=lp.pointer(); 
+	    if (VhdlDocGen::compareArgList(l,func->argList))
+	    {
+	      mdd->setDocumentation(func->doc.data(),func->docFile.data(),func->docLine,TRUE);
+	      mdd->setBriefDescription(func->brief,func->briefFile,func->briefLine);
+	      addMemberToGroups(func,mdd);// do not forget grouping!
+	      return func;
+	    }  
+	  }
+	}
+      }
+    }// if
+  }//for
+  return 0;
+}// findFunction
+
+/*
+ * adds the documentation for a function|procedure 
+ */ 
+
+void VhdlDocGen::addFuncDoc(EntryNav* rootNav)
+{
+  Entry *root = rootNav->entry();
+  if (root &&  root->spec==VhdlDocGen::DOCUMENT)
+  {
+    Entry *func=VhdlDocGen::findFunction(root);
+    if (!func && Config_getBool("WARNINGS"))
+    {
+      warn(root->fileName,root->docLine,
+      "Warning: documentation for unknown function %s found.\n",
+      root->name.data()
+      );
+    }
+  }
+}// AddFuncDoc
+
+/*! 
+ * returns the class title+ref
+ */
+
+QCString VhdlDocGen::getClassTitle(const ClassDef *cd)
+{
+  QCString pageTitle;
+  if (cd==0) return "";
+  pageTitle+=cd->displayName();
+  pageTitle=VhdlDocGen::getClassName(cd);
+  int ii=cd->protection();
+  pageTitle+=" ";
+  pageTitle+=theTranslator_vhdlType(ii+2,TRUE);
+  pageTitle+=" ";
+  return pageTitle;
+} // getClassTitle
+
+/* returns the class name without their prefixes */
+
+QCString VhdlDocGen::getClassName(const ClassDef* cd)
+{
+  QCString temp;
+  if (cd==0) return "";
+
+  if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)
+  { 
+    temp=cd->name();
+    temp.stripPrefix("_");
+    return temp;
+  }  
+  //if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ARCHITECTURECLASS)
+  //{  
+  //  QStringList qlist=QStringList::split("-",cd->className(),FALSE);
+  //  if (qlist.count()>1)
+  //    return (QCString)qlist[1];
+  //  return "";
+  //}
+  return substitute(cd->className(),"::",".");
+}
+
+/*! 
+ * writes an inline link form entity|package to architecture|package body and vice verca
+ */
+
+void VhdlDocGen::writeInlineClassLink(const ClassDef* cd ,OutputList& ol)
+{
+  QList<QCString> ql;
+  ql.setAutoDelete(TRUE);
+  QCString nn=cd->className();
+  int ii=(int)cd->protection()+2;
+
+  QCString type;
+  if (ii==VhdlDocGen::ENTITY)
+    type+=theTranslator_vhdlType(VhdlDocGen::ARCHITECTURE,TRUE);
+  else if (ii==VhdlDocGen::ARCHITECTURE)
+    type+=theTranslator_vhdlType(VhdlDocGen::ENTITY,TRUE);
+  else if (ii==VhdlDocGen::PACKAGE_BODY)
+    type+=theTranslator_vhdlType(VhdlDocGen::PACKAGE,TRUE);
+  else if (ii==VhdlDocGen::PACKAGE)
+    type+=theTranslator_vhdlType(VhdlDocGen::PACKAGE_BODY,TRUE);
+  else 
+    type+="";
+
+  //type=type.lower(); 
+  type+=" >> ";
+  ol.disable(OutputGenerator::RTF); 
+  ol.disable(OutputGenerator::Man);
+  ol.lineBreak();
+  ol.lineBreak();
+
+  if (ii==VhdlDocGen::PACKAGE_BODY) 
+  {
+    nn.stripPrefix("_");
+    cd=getClass(nn.data());
+  }
+  else  if (ii==VhdlDocGen::PACKAGE) 
+  {
+    nn.prepend("_");
+    cd=getClass(nn.data());
+  }
+  else if (ii==VhdlDocGen::ARCHITECTURE)
+  {
+    QStringList qlist=QStringList::split("-",nn,FALSE);
+    nn=qlist[1];
+    cd=VhdlDocGen::getClass(nn.data());
+  }       
+
+  QCString opp;
+  if (ii==VhdlDocGen::ENTITY)
+  { 
+    VhdlDocGen::findAllArchitectures(ql,cd);
+    int j=ql.count();
+    for (int i=0;i<j;i++)
+    {
+      QCString *temp=ql.at(i);
+      QStringList qlist=QStringList::split("-",*temp,FALSE);
+      QCString s1=(QCString)qlist[0];
+      QCString s2=(QCString)qlist[1];
+      s1.stripPrefix("_");
+      if (j==1) s1.resize(0);
+      ClassDef*cc = getClass(temp->data());
+      if (cc)
+      {
+	VhdlDocGen::writeVhdlLink(cc,ol,type,s2,s1); 
+      }
+    }    
+  }  
+  else
+  {
+    VhdlDocGen::writeVhdlLink(cd,ol,type,nn,opp);
+  }
+
+  ol.enable(OutputGenerator::Man);
+  ol.enable(OutputGenerator::RTF);
+
+}// write
+
+/*
+ * finds all architectures which belongs to an entiy
+ */
+void VhdlDocGen::findAllArchitectures(QList<QCString>& qll,const ClassDef *cd)
+{
+  ClassDef *citer;
+  ClassSDict::Iterator cli(*Doxygen::classSDict);
+  for ( ; (citer=cli.current()) ; ++cli )
+  {
+    QCString jj=citer->className();
+    if (cd != citer && jj.contains('-')!=-1)
+    {
+      QStringList ql=QStringList::split("-",jj,FALSE);
+      QCString temp=(QCString)ql[1];
+      if (stricmp(cd->className().data(),temp.data())==0) 
+      {
+	QCString *cl=new QCString(jj.data());
+	qll.insert(0,cl);
+      }
+    }           
+  }// for
+}//findAllArchitectures
+
+/*
+ * writes the link entity >> .... or architecture >> ... 
+ */
+
+void VhdlDocGen::writeVhdlLink(const ClassDef* ccd ,OutputList& ol,QCString& type,QCString& nn,QCString& behav)
+{
+  if (ccd==0)  return;
+  QCString temp=ccd->getOutputFileBase();
+  ol.startBold();
+  ol.docify(type.data());
+  ol.endBold();
+  nn.stripPrefix("_");
+  ol.writeObjectLink(ccd->getReference(),ccd->getOutputFileBase(),0,nn.data());
+
+  if (!behav.isEmpty()) 
+  {
+    behav.prepend("  ");
+    ol.startBold();
+    ol.docify(behav.data());
+    ol.endBold();
+  }
+  /*
+     if (Config_getBool("SOURCE_BROWSER")) { // writes a source link for latex docu
+     ol.pushGeneratorState();
+     ol.disableAllBut(OutputGenerator::Latex);
+     ol.docify(" | ");
+     ol.startEmphasis();
+     FileDef* fd=ccd->getFileDef();
+     if (fd)
+     ol.writeObjectLink(0,fd->getSourceFileBase(),0,theTranslator->trGotoSourceCode().data());
+     ol.endEmphasis();
+     ol.popGeneratorState();
+     }
+   */    
+  ol.lineBreak();
+}
+
+bool VhdlDocGen::compareString(const QCString& s1,const QCString& s2)
+{
+  QCString str1=s1.stripWhiteSpace();
+  QCString str2=s2.stripWhiteSpace();
+
+  return stricmp(str1.data(),str2.data());
+}
+
+bool VhdlDocGen::getSigTypeName(QList<QCString>& ql, const char* str,QCString& buffer)
+{
+  QCString temp(str);
+  QStringList qlist=QStringList::split(" is ",temp,FALSE);
+  if (qlist.count()!=2) return FALSE;
+  temp.resize(0);
+  temp+=(QCString)qlist[0]+":"+(QCString)qlist[1];
+  return VhdlDocGen::getSigName(ql,temp.data(),buffer);  
+}
+
+/*!
+ * divides a port input   in its name,direction and type
+ * @param ql stores the input name(s)
+ * @param str input string
+ * @param buffer stores the input direction
+ * @returns FALSE if it is a port
+ */
+
+bool VhdlDocGen::getSigName(QList<QCString>& ql, 
+                            const char* str,QCString& buffer)
+{
+  int len,j,ll,index;
+  char *signal = "signal ";
+  QCString qmem;
+  QCString temp(str);
+  QCString st(str);
+
+  QRegExp semi(",");
+  QRegExp r(":");
+  j = r.match(temp.data(),0,&len);
+  if (j < 0) return FALSE; // no input definition
+  st=st.left(j);
+  index=st.find(signal,0,FALSE);
+  if (index > -1)
+  {
+    qmem=st.remove(index,strlen(signal));
+    temp=qmem;
+    st=qmem;
+  }
+  else
+  {
+    qmem=temp;
+  }
+
+  ll=semi.match(st.data(),0,&len);
+
+  if (ll>0)
+  {
+    while (TRUE)
+    {
+      st=st.left(ll);
+      QCString *sig =new QCString(st);
+      ql.insert(0,sig);
+      qmem=qmem.right(qmem.length()-ll-1);
+      st=qmem;
+      ll=semi.match(st.data(),0,&len);
+      if (ll<0)
+      {
+	ll = r.match(st.data(),0,&len);
+	st=st.left(ll);
+	ql.insert(0,new QCString(st));
+	break;
+      }
+    }
+  }
+  else 
+  {
+    st=st.left(j);
+    ql.insert(0,new QCString(st));
+  }
+  QCString *qdir=new QCString(str);
+  st=qdir->mid(j+1);
+  //st=st.lower();
+  st=st.stripWhiteSpace();
+  *qdir=st;
+
+  ql.insert(0,qdir);
+  if (st.stripPrefix("inout"))
+  {
+    buffer+="inout";
+    return TRUE;
+  }
+
+  if (st.stripPrefix("out"))
+  {
+    buffer+="out";
+    return TRUE;
+  }
+
+  if (st.stripPrefix("in"))
+  {
+    buffer+="in";
+    return TRUE;
+  }
+  return FALSE;
+}
+
+/*!
+ * divides a process string in its name and types
+ * @param text process text
+ * @param name points to the process name
+ * @param ql stores the process types
+ */
+
+void VhdlDocGen::parseProcessProto(const char* text,
+                                  QCString& name,QStringList& ql)
+{
+  int index,end;
+  const char *s=":";
+  QCString temp;
+  QCString s1(text);
+  index=s1.find(s,0,FALSE);
+  if (index >=0)
+  {
+    name=s1.left(index);
+    //  strcpy(name,tt.data());
+  }
+
+  index=s1.find("(",0,FALSE);
+  end=s1.findRev(")",s1.length(),FALSE);
+  // end=s1.find(")",0,FALSE);
+
+  if ((end-index)>1) 
+  {
+    temp=s1.mid(index+1,(end-index-1));
+    ql=QStringList::split(",",temp,FALSE);
+  }
+}//parseProcessProto
+
+/*!
+ * strips the "--" prefixes of vhdl comments 
+ */
+void VhdlDocGen::prepareComment(QCString& qcs)
+{
+  QCString temp;
+  const char* s="--!";
+  //const char *start="--!{";
+  //const char *end="--!}";
+  int index=0; 
+
+#if 0
+  index=qcs.find(start,0,TRUE);
+  if (index>0)
+    temp=qcs.remove(index,strlen(start));
+  qcs=temp;
+
+  index=qcs.find(end,0,TRUE);
+  if (index>0)
+    temp=qcs.remove(index,strlen(end));
+  qcs=temp;
+#endif
+  while (TRUE)
+  {
+    index=qcs.find(s,0,TRUE);
+    if (index<0) break;
+    temp=qcs.remove(index,strlen(s));
+    qcs=temp;
+  }
+  qcs=qcs.stripWhiteSpace();
+}
+
+
+/*!
+ * parses a function proto
+ * @param text function string
+ * @param qlist stores the function types
+ * @param name points to the function name
+ * @param ret Stores the return type
+ * @param doc ???
+ */
+void VhdlDocGen::parseFuncProto(const char* text,QList<Argument>& qlist,
+                                QCString& name,QCString& ret,bool doc)
+{
+  int index,end;
+  QCString s1(text);
+  QCString temp;
+
+  index=s1.find("(");
+  end=s1.findRev(")");
+
+  if ((end-index)>0) 
+  {
+    QCString tt=s1.mid(index,(end-index+1));
+    temp=s1.mid(index+1,(end-index-1));
+    getFuncParams(qlist,temp);
+  } 
+  if (doc)
+  {
+    name=s1.left(index);
+    name=name.stripWhiteSpace();
+    if ((end-index)>0) 
+    { 
+      ret="function";
+    }  
+    return;
+  }
+  else
+  {  
+    QCString s1(text);
+    s1=s1.stripWhiteSpace();
+    int i=s1.find("(",0,FALSE);
+    int s=s1.find(" ",0,FALSE);
+    if (i==-1)
+      s1=VhdlDocGen::getIndexWord(s1.data(),1);
+    else
+      s1=s1.mid(s,(i-s));
+
+    name=s1.stripWhiteSpace();
+  }
+  index=s1.findRev("return",-1,FALSE);
+  if (index !=-1)
+  {
+    ret=s1.mid(index+6,s1.length());
+    ret=ret.stripWhiteSpace();
+    VhdlDocGen::deleteCharRev(ret,';');
+  }
+}
+
+/*
+ *  returns the n'th word of a string
+ */
+
+QCString VhdlDocGen::getIndexWord(const char* c,int index)
+{
+  QStringList ql;
+  QCString temp(c);
+  QRegExp reg("[\\s]");
+
+  ql=QStringList::split(reg,temp,FALSE);
+
+  if (ql.count() > (unsigned int)index)
+  {
+    return (QCString)ql[index];
+  }
+
+  return "";
+}
+
+
+/*!
+ * \brief returns the arguments of a function or procedure prototype
+ * @param ql list ql stores the arguments
+ * @param str prototype
+ */
+
+void VhdlDocGen::getFuncParams(QList<Argument>& ql, const char* str)
+{
+
+  int len;
+  QCString qmem,s1,s2,ttype;
+  QCString temp(str);
+  temp=temp.stripWhiteSpace();
+  if (temp.isEmpty()) return;
+
+  QCString st(str);
+  QStringList strList;
+
+  strList=QStringList::split(";",temp,FALSE);
+  int kk=strList.count();
+  int j=kk;
+  while (kk>=1)
+  {
+    temp=strList[j-kk];
+    QStringList tempList,tt;
+    tempList=QStringList::split(":",temp,FALSE);
+    if (tempList.count()>2)
+      ttype=tempList[1];
+    else
+      ttype=tempList.last();
+
+    ttype=ttype.stripWhiteSpace();
+
+    uint zui=ttype.contains('(',FALSE);
+    if (zui == 0)
+      tt=QStringList::split(" ",ttype,FALSE);
+    else
+    {
+      if (ttype.stripPrefix("in"))
+	tt.append("in");
+      else if (ttype.stripPrefix("out"))
+	tt.append("out");
+      else if (ttype.stripPrefix("inout"))
+	tt.append("inout");
+      if (ttype.stripPrefix("IN"))
+	tt.append("in");
+      else if (ttype.stripPrefix("OUT"))
+	tt.append("out");
+      else if (ttype.stripPrefix("INOUT"))
+	tt.append("inout");
+
+      ttype=ttype.stripWhiteSpace();
+      tt.append(ttype);
+    }
+
+    s1=tt.first();
+    //s1=s1.lower();
+
+    if (tempList.count()>2)
+      s2=tt.last()+":"+tempList[2];
+    else
+      s2=tt.last();
+
+    QCString first=(QCString)tempList.first();
+
+    tempList.clear();
+    tt.clear();
+
+    tempList=QStringList::split(",",first,FALSE);
+    len=tempList.count();
+    ttype.resize(0);
+    for (int j=0;j<len;j++)
+    {
+      Argument *arg=new Argument;
+      QCString name=(QCString)tempList[j];
+      name=name.stripWhiteSpace();
+
+      tt=QStringList::split(" ",name,FALSE);
+      if (tt.count() > 1)
+	ttype=(tt.first()).stripWhiteSpace();
+
+      arg->defval=ttype.copy();
+      arg->type=s2.stripWhiteSpace();
+      arg->attrib=s1.stripWhiteSpace();
+      arg->name=(tt.last()).stripWhiteSpace();
+
+      //     printf("--proto \n [%s] [%s] [%s] [%s] [%s]",ttype.data(),arg->type.data(),arg->attrib.data(),arg->name.data(),s1.data());
+      ql.append(arg);
+    }
+    kk--;
+  }//while
+} // getFuncName
+
+
+QCString VhdlDocGen::trTypeString(int type)
+{
+  switch(type)
+  {
+    case VhdlDocGen::LIBRARY:      return "Library"; 
+    case VhdlDocGen::ENTITY:       return "Entity";
+    case VhdlDocGen::PACKAGE_BODY: return "Package Body";
+    case VhdlDocGen::ATTRIBUTE:    return "Attribute";
+    case VhdlDocGen::PACKAGE:      return "Package";
+    case VhdlDocGen::SIGNAL:       return "Signal";
+    case VhdlDocGen::COMPONENT:    return "Component";
+    case VhdlDocGen::CONSTANT:     return "Constant";
+    case VhdlDocGen::TYPE:         return "Type";
+    case VhdlDocGen::SUBTYPE:      return "Subtype";
+    case VhdlDocGen::FUNCTION:     return "Function";
+    case VhdlDocGen::RECORD:       return "Record";
+    case VhdlDocGen::PROCEDURE:    return "Procedure";
+    case VhdlDocGen::ARCHITECTURE: return "Architecture";
+    case VhdlDocGen::USE:          return "Package";
+    case VhdlDocGen::PROCESS:      return "Process";
+    case VhdlDocGen::PORT:         return "Port";
+    case VhdlDocGen::GENERIC:      return "Generic";
+    case VhdlDocGen::DOCUMENT:     return "Doc"; 
+    case VhdlDocGen::UNITS:        return "Units"; 
+    case VhdlDocGen::PORTMAP:      return "Port Map"; 
+    default:                       return "";
+  }
+} // convertType
+
+/*!
+ * deletes a char backwards in a string 
+ */
+
+bool VhdlDocGen::deleteCharRev(QCString &s,char c)
+{
+  int index=s.findRev(c,-1,FALSE);
+  if (index > -1)
+  {
+    QString qcs=s.remove(index,1);
+    s=qcs;
+    return TRUE;
+  }
+  return FALSE;
+}
+
+void VhdlDocGen::deleteAllChars(QCString &s,char c)
+{
+  int index=s.findRev(c,-1,FALSE);
+  while (index > -1)
+  {
+    QString qcs=s.remove(index,1);      
+    s=qcs;
+    index=s.findRev(c,-1,FALSE);
+  }  
+}
+
+
+static int recordCounter=0; 
+
+/*!
+ * returns the next number of a record|unit member
+ */
+
+QCString VhdlDocGen::getRecordNumber()
+{
+  char buf[12];
+  sprintf(buf,"%d",recordCounter++);
+  QCString qcs(&buf[0]);
+  return qcs;
+}
+
+/*!
+ * returns the next number of an anonymous process
+ */
+
+QCString VhdlDocGen::getProcessNumber()
+{
+  static int stringCounter;
+  char buf[8];
+  QCString qcs("PROCESS_");
+  sprintf(buf,"%d",stringCounter++);
+  qcs.append(&buf[0]);
+  return qcs;
+}
+
+/*!
+ * writes a colored and formatted string 
+ */
+
+void VhdlDocGen::writeFormatString(QCString& qcs,OutputList&ol,const MemberDef* mdef)
+{
+  QRegExp reg("[\\/\\:\\<\\>\\:\\s\\,\\;\\'\\+\\-\\*\\|\\&\\=\\(\\)\"]");
+  qcs+=QCString(" ");// parsing the last sign
+  QCString *ss;
+  QCString find=qcs;
+  QCString temp=qcs;
+  char buf[2];
+  buf[1]='\0';
+
+  int j;
+  int len;
+  j = reg.match(temp.data(),0,&len);
+
+  ol.startBold();
+  if (j>=0)
+  {
+    while (j>=0)
+    {
+      find=find.left(j);
+      buf[0]=temp[j];
+      ss=VhdlDocGen::findKeyWord(find);
+      bool k=VhdlDocGen::isNumber(find); // is this a number
+      if (k)
+      {
+	VhdlDocGen::startFonts(find,"vhdldigit",ol);
+      }
+      else if (j != 0 && ss)
+      {
+	VhdlDocGen::startFonts(find,ss->data(),ol);
+      }
+      else
+      {
+	if (j>0)
+	{
+	  VhdlDocGen::writeStringLink(mdef,find,ol);
+	}
+      }
+      VhdlDocGen::startFonts(&buf[0],"vhdlchar",ol);
+
+      QCString st=temp.remove(0,j+1);
+      find=st;
+      temp=st;
+      j = reg.match(temp.data(),0,&len);
+    }//while
+  }//if
+  else
+  {
+    VhdlDocGen::startFonts(find,"vhdlchar",ol);     
+  }
+  ol.endBold();
+}// writeFormatString
+
+/*!
+ * returns TRUE if this string is a number
+ */
+
+bool VhdlDocGen::isNumber(const QCString& s)
+{
+  int len=s.length();
+  if (len==0) return FALSE;
+  for (int j=0;j<len;j++)
+  {
+    if (isdigit((int)(s.at(j) & 0xff))==0)
+      return FALSE;
+  }
+  return TRUE;
+}// isNumber
+
+
+void VhdlDocGen::startFonts(const QCString& q, char *keyword,OutputList& ol)
+{
+  ol.startFontClass(keyword);
+  ol.docify(q.data());
+  ol.endFontClass();
+}
+
+/*!
+ * inserts white spaces for  better readings  
+ * and writes a colored string to the output
+ */
+
+void VhdlDocGen::formatString(QCString & qcs, OutputList& ol,const MemberDef* mdef)
+{ 
+  QCString temp(qcs.length());  
+  qcs.stripPrefix(":");
+  qcs.stripPrefix("is");
+  qcs.stripPrefix("IS");
+  qcs.stripPrefix("of");
+  qcs.stripPrefix("OF");
+
+  VhdlDocGen::deleteCharRev(qcs,';');
+  //char white='\t';
+  int len = qcs.length();
+  unsigned int index=1;//temp.length();
+
+  for (int j=0;j<len;j++)
+  {
+    char c=qcs[j];
+    char b=c;
+    if (j>0) b=qcs[j-1];
+    if (c=='"' || c==',' || c==';' || c=='\''|| c=='(' || c==')'  || c==':' ) // || (c==':' && b!='=')) // || (c=='=' && b!='>')) 
+    {
+      if (temp.at(index-1) != ' ')
+      {
+	temp+=" ";
+      }
+      temp+=QCString(&c,1);
+      temp+=" "; 
+    }
+    else if (c=='=') 
+    {
+      if (b==':') // := operator
+      {   
+	temp.replace(index-1,1,"=");
+	temp+=" "; 
+      }
+      else // = operator
+      {
+	temp+=" ";      
+	temp+=QCString(&c,1);
+	temp+=" "; 
+      }
+    }
+    else      
+    {
+      temp+=QCString(&c,1);
+    }
+
+    index=temp.length();
+  }// for
+  temp=temp.stripWhiteSpace();
+  // printf("\n [%s]",qcs.data());
+  VhdlDocGen::writeFormatString(temp,ol,mdef);
+}
+
+/*!
+ * writes a procedure prototype to the output
+ */
+
+void VhdlDocGen::writeProcedureProto(OutputList& ol,const ArgumentList* al,const MemberDef* mdef)
+{
+  ArgumentListIterator ali(*al);
+  Argument *arg;
+  bool sem=FALSE;
+  int len=al->count();
+  ol.docify("( ");    
+  if (len > 2)
+  {
+    ol.lineBreak();
+  }
+  for (;(arg=ali.current());++ali)
+  {
+    ol.startBold();
+    if (sem && len <3)
+      ol.writeChar(',');
+
+    QCString nn=arg->name;
+    nn+=": ";
+
+    QCString *str=VhdlDocGen::findKeyWord(arg->defval);
+    arg->defval+=" ";
+    if (str) 
+    {
+      VhdlDocGen::startFonts(arg->defval,str->data(),ol);
+    }
+    else
+    {
+      VhdlDocGen::startFonts(arg->defval,"vhdlchar",ol); // write type (variable,constant etc.)
+    }
+
+    VhdlDocGen::startFonts(nn,"vhdlchar",ol); // write name 
+    if (stricmp(arg->attrib.data(),arg->type.data()) != 0)
+      VhdlDocGen::startFonts(arg->attrib.lower(),"stringliteral",ol); // write in|out
+    ol.docify(" ");
+    VhdlDocGen::formatString(arg->type,ol,mdef);
+    sem=TRUE;
+    ol.endBold();
+    if (len > 2)
+    { 
+      ol.lineBreak();
+      ol.docify("  ");
+    }
+  }//for
+
+  ol.docify(" )");    
+
+
+}// writePorcedure
+
+/*!
+ * writes a function prototype to the output
+ */
+
+void VhdlDocGen::writeFunctionProto(OutputList& ol,const ArgumentList* al,const MemberDef* mdef)
+{
+  if (al==0) return;
+  ArgumentListIterator ali(*al);
+  Argument *arg;
+  bool sem=FALSE;
+  int len=al->count();
+  ol.startBold();
+  ol.docify(" ( ");    
+  ol.endBold();
+  if (len>2)
+  {
+    ol.lineBreak();
+  }
+  for (;(arg=ali.current());++ali)
+  {
+    ol.startBold();
+    if (sem && len < 3)
+    {
+      ol.docify(" , ");
+    }
+    QCString att=arg->defval;
+    if (!att.isEmpty()) 
+    { 
+      QCString *str=VhdlDocGen::findKeyWord(att);
+      att+=" ";
+      if (str)
+	VhdlDocGen::formatString(att,ol,mdef);
+      else
+	VhdlDocGen::startFonts(att,"vhdlchar",ol);         
+    }  
+
+    QCString nn=arg->name;
+    nn+=": ";
+    QCString ss=arg->type; //.lower();
+    QCString w=ss;//.upper();
+    VhdlDocGen::startFonts(nn,"vhdlchar",ol);
+    VhdlDocGen::startFonts("in ","stringliteral",ol);
+    QCString *str=VhdlDocGen::findKeyWord(ss);
+    if (str)
+      VhdlDocGen::formatString(w,ol,mdef);
+    else
+      VhdlDocGen::startFonts(w,"vhdlchar",ol);         
+
+    sem=TRUE;    
+    ol.endBold();
+    if (len > 2)    
+    {
+      ol.lineBreak();
+    }
+  }
+  ol.startBold();    
+  ol.docify(" )");    
+  ol.endBold();  
+}
+
+/*!
+ * writes a process prototype to the output
+ */
+
+void VhdlDocGen::writeProcessProto(OutputList& ol,const ArgumentList* al,const MemberDef* mdef)
+{
+  if (al==0) return;
+  ArgumentListIterator ali(*al);
+  Argument *arg;
+  bool sem=FALSE;
+  ol.startBold();
+  ol.docify(" ( ");    
+  for (;(arg=ali.current());++ali)
+  {
+    if (sem)
+      ol.docify(" , ");
+    QCString nn=arg->name;
+    // VhdlDocGen::startFonts(nn,"vhdlchar",ol);
+    VhdlDocGen::writeFormatString(nn,ol,mdef);
+    sem=TRUE;    
+  }    
+  ol.docify(" )");    
+  ol.endBold();
+}
+
+
+/*!
+ * writes a function|procedure documentation to the output
+ */
+
+void VhdlDocGen::writeFuncProcDocu(
+    const MemberDef *md, 
+    OutputList& ol,
+    const ArgumentList* al,
+    bool /*type*/)
+{
+  if (al==0) return;
+  bool sem=FALSE;    
+  ol.enableAll();
+
+  ArgumentListIterator ali(*al);
+  int index=ali.count();
+  if (index==0){
+    ol.docify(" ( ) ");
+    return;
+  }
+  ol.startParameterList(TRUE); 
+  Argument *arg;
+  bool first=TRUE;
+  for (;(arg=ali.current());++ali)
+  { 
+    ol.startParameterType(first,"");  
+    if (!VhdlDocGen::isProcess(md))
+    {
+      if (TRUE) //VhdlDocGen::isProcedure(md))
+      {
+	startFonts(arg->defval,"keywordtype",ol);
+	ol.docify(" ");
+      } 
+      // linkifyText(TextGeneratorOLImpl(ol),md->getClassDef(),md->getBodyDef(),md->name(),arg->type);
+      VhdlDocGen::writeFormatString(arg->name,ol,md);
+      ol.docify(" ");
+
+      if (VhdlDocGen::isProcedure(md))
+	startFonts(arg->attrib,"stringliteral",ol);
+      else
+	startFonts(QCString("in"),"stringliteral",ol);
+    }
+    ol.docify(" ");
+    ol.disable(OutputGenerator::Man);
+    ol.startEmphasis();
+    ol.enable(OutputGenerator::Man);
+    if (!VhdlDocGen::isProcess(md))
+      startFonts(arg->type,"vhdlkeyword",ol);
+    else
+      startFonts(arg->name,"vhdlkeyword",ol);
+    ol.disable(OutputGenerator::Man);
+    ol.endEmphasis();
+    ol.enable(OutputGenerator::Man);
+
+    if (--index) 
+      ol.docify(" , ");    
+    else
+      ol.docify(" ) ");
+
+    ol.endParameterName(FALSE,FALSE,FALSE); 
+
+    sem=TRUE;        
+    first=FALSE;
+  }
+
+} // writeDocFunProc
+
+/*!
+ * returns TRUE if this string is a function prototype or 
+ * FALSE if this is a procedure
+ */
+
+bool VhdlDocGen::isFunctionProto(QCString& ss)
+{
+  QCString name=ss;
+  QCString proc("procedure");
+  QCString func("function");
+  name=name.stripWhiteSpace();
+  QStringList ql=QStringList::split(" ",name,FALSE);
+  int j=ql.count();
+  if (j<2) return FALSE;
+  QCString tt=(QCString)ql[0];
+
+  if (VhdlDocGen::compareString(tt,proc)!=0 && VhdlDocGen::compareString(tt,func)!=0) 
+    return FALSE;
+
+  QCString temp=(QCString)ql[j-1];
+  temp=temp.stripWhiteSpace();
+  if (stricmp(temp.data(),"is")==0)
+  {
+    VhdlDocGen::deleteCharRev(name,'s');
+    VhdlDocGen::deleteCharRev(name,'i');
+    ss=name;
+    return TRUE;
+  }
+  return FALSE;
+}
+
+QCString VhdlDocGen::convertArgumentListToString(const ArgumentList* al,bool func)
+{
+  QCString argString;
+  bool sem=FALSE;
+  ArgumentListIterator ali(*al);
+  Argument *arg;
+
+  for (;(arg=ali.current());++ali)
+  {
+    if (sem) argString.append(", ");
+    if (func)
+    {
+      argString+=arg->name;
+      argString+=":";
+      argString+=arg->type; 
+    }
+    else
+    {
+      argString+=arg->defval+" ";
+      argString+=arg->name+" :";
+      argString+=arg->attrib+" ";
+      argString+=arg->type;
+    } 
+    sem=TRUE;
+  }
+  return argString;
+}
+
+
+void VhdlDocGen::writeVhdlDeclarations(MemberList* ml,
+                             OutputList& ol,GroupDef* gd,ClassDef* cd)
+{
+  static ClassDef *cdef;
+  static GroupDef* gdef;
+  if (cd && cdef!=cd)
+  { // only one inline link
+    VhdlDocGen::writeInlineClassLink(cd,ol);
+    cdef=cd;
+  }
+
+  if (gd && gdef==gd) return;
+  if (gd && gdef!=gd)
+  {
+    gdef=gd;
+  }
+
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::LIBRARY,FALSE),0,FALSE,VhdlDocGen::LIBRARY);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::USE,FALSE),0,FALSE,VhdlDocGen::USE);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::FUNCTION,FALSE),0,FALSE,VhdlDocGen::FUNCTION);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::COMPONENT,FALSE),0,FALSE,VhdlDocGen::COMPONENT);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::CONSTANT,FALSE),0,FALSE,VhdlDocGen::CONSTANT);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::TYPE,FALSE),0,FALSE,VhdlDocGen::TYPE);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::SUBTYPE,FALSE),0,FALSE,VhdlDocGen::SUBTYPE);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::GENERIC,FALSE),0,FALSE,VhdlDocGen::GENERIC);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::PORT,FALSE),0,FALSE,VhdlDocGen::PORT);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::PROCESS,FALSE),0,FALSE,VhdlDocGen::PROCESS);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::SIGNAL,FALSE),0,FALSE,VhdlDocGen::SIGNAL);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::ATTRIBUTE,FALSE),0,FALSE,VhdlDocGen::ATTRIBUTE);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::PROCEDURE,FALSE),0,FALSE,VhdlDocGen::PROCEDURE);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::RECORD,FALSE),0,FALSE,VhdlDocGen::RECORD);
+  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,0,0,gd,theTranslator_vhdlType(VhdlDocGen::UNITS,FALSE),0,FALSE,VhdlDocGen::UNITS);
+
+
+}
+
+/* writes a vhdl type documentation */
+void VhdlDocGen::writeVHDLTypeDocumentation(const MemberDef* mdef, const Definition *d, OutputList &ol)
+{
+  ClassDef *cd=(ClassDef*)d;
+  if (cd==0) return;
+  if ((VhdlDocGen::isVhdlFunction(mdef) || VhdlDocGen::isProcedure(mdef) || VhdlDocGen::isProcess(mdef)))
+  {
+    QCString nn=mdef->typeString();
+    nn=nn.stripWhiteSpace();
+    QCString na=cd->name();
+    MemberDef* memdef=VhdlDocGen::findMember(na,nn);
+    if (memdef && memdef->isLinkable()) 
+    { 
+      ol.startBold();
+      ol.writeObjectLink(cd->getReference(),cd->getOutputFileBase(),0,mdef->typeString());                
+      ol.endBold();
+      ol.docify(" ");
+    }
+    else
+    {
+      QCString ttype=mdef->typeString();
+      VhdlDocGen::formatString(ttype,ol,mdef);
+    }
+    ol.docify(mdef->name());
+    VhdlDocGen::writeFuncProcDocu(mdef,ol, mdef->argumentList().pointer());
+  }
+
+  if (mdef->isVariable())
+  { 
+    ol.docify(mdef->name().data());
+    ol.docify(" ");
+    QCString ttype=mdef->typeString();
+    VhdlDocGen::formatString(ttype,ol,mdef);
+    ol.docify(" ");
+    if (VhdlDocGen::isPort(mdef))
+    {
+      QCString largs=mdef->argsString();
+      VhdlDocGen::formatString(largs,ol,mdef);
+      ol.docify(" ");
+    }
+  }
+}
+
+/* writes a vhdl type declaration */
+
+void VhdlDocGen::writeVHDLDeclaration(MemberDef* mdef,OutputList &ol,
+    ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
+    bool /*inGroup*/) 
+{
+
+  LockingPtr<MemberDef> lock(mdef,mdef);
+
+  Definition *d=0;
+  ASSERT (cd!=0 || nd!=0 || fd!=0 || gd!=0); // member should belong to something
+  if (cd) d=cd; else if (nd) d=nd; else if (fd) d=fd; else d=gd;
+
+  // write tag file information of this member
+  if (!Config_getString("GENERATE_TAGFILE").isEmpty())
+  {
+    Doxygen::tagFile << "    <member kind=\"";
+    if      (VhdlDocGen::isGeneric(mdef))      Doxygen::tagFile << "generic";
+    if      (VhdlDocGen::isPort(mdef))         Doxygen::tagFile << "port";
+    if      (VhdlDocGen::isEntity(mdef))       Doxygen::tagFile << "entity";
+    if      (VhdlDocGen::isComponent(mdef))    Doxygen::tagFile << "component";
+    if      (VhdlDocGen::isVType(mdef))        Doxygen::tagFile << "type";
+    if      (VhdlDocGen::isConstant(mdef))     Doxygen::tagFile << "constant";
+    if      (VhdlDocGen::isSubType(mdef))      Doxygen::tagFile << "subtype";
+    if      (VhdlDocGen::isVhdlFunction(mdef)) Doxygen::tagFile << "function";
+    if      (VhdlDocGen::isProcedure(mdef))    Doxygen::tagFile << "procedure";
+    if      (VhdlDocGen::isProcess(mdef))      Doxygen::tagFile << "process";
+    if      (VhdlDocGen::isSignals(mdef))      Doxygen::tagFile << "signal";
+    if      (VhdlDocGen::isAttribute(mdef))    Doxygen::tagFile << "attribute";
+    if      (VhdlDocGen::isRecord(mdef))       Doxygen::tagFile << "record";
+    if      (VhdlDocGen::isLibrary(mdef))      Doxygen::tagFile << "library";
+    if      (VhdlDocGen::isPackage(mdef))      Doxygen::tagFile << "package";
+
+    Doxygen::tagFile << "\">" << endl;
+    Doxygen::tagFile << "      <type>" << convertToXML(mdef->typeString()) << "</type>" << endl;
+    Doxygen::tagFile << "      <name>" << convertToXML(mdef->name()) << "</name>" << endl;
+    Doxygen::tagFile << "      <anchorfile>" << convertToXML(mdef->getOutputFileBase()+Doxygen::htmlFileExtension) << "</anchorfile>" << endl;
+    Doxygen::tagFile << "      <anchor>" << convertToXML(mdef->anchor()) << "</anchor>" << endl;
+
+    if (VhdlDocGen::isVhdlFunction(mdef))
+      Doxygen::tagFile << "      <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList().pointer(),TRUE)) << "</arglist>" << endl;
+    else if (VhdlDocGen::isProcedure(mdef))
+      Doxygen::tagFile << "      <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList().pointer(),FALSE)) << "</arglist>" << endl;
+    else
+      Doxygen::tagFile << "      <arglist>" << convertToXML(mdef->argsString()) << "</arglist>" << endl;
+
+    mdef->writeDocAnchorsToTagFile();
+    Doxygen::tagFile << "    </member>" << endl;
+
+  }
+
+  // write search index info
+  if (Config_getBool("SEARCHENGINE"))
+  {
+    Doxygen::searchIndex->setCurrentDoc(mdef->qualifiedName(),mdef->getOutputFileBase(),mdef->anchor());
+    Doxygen::searchIndex->addWord(mdef->localName(),TRUE);
+    Doxygen::searchIndex->addWord(mdef->qualifiedName(),FALSE);
+  }
+
+  QCString cname  = d->name();
+  QCString cfname = mdef->getOutputFileBase();
+
+  //HtmlHelp *htmlHelp=0;
+  //  bool hasHtmlHelp = Config_getBool("GENERATE_HTML") && Config_getBool("GENERATE_HTMLHELP");
+  //  if (hasHtmlHelp) htmlHelp = HtmlHelp::getInstance();
+
+  // search for the last anonymous scope in the member type
+  ClassDef *annoClassDef=mdef->getClassDefOfAnonymousType();
+
+  // start a new member declaration
+  bool isAnonymous = annoClassDef; // || m_impl->annMemb || m_impl->annEnumType;
+  ///printf("startMemberItem for %s\n",name().data());
+  ol.startMemberItem( isAnonymous ); //? 1 : m_impl->tArgList ? 3 : 0);
+
+  // If there is no detailed description we need to write the anchor here.
+  bool detailsVisible = mdef->isDetailedSectionLinkable();
+  if (!detailsVisible) // && !m_impl->annMemb)
+  {
+    QCString doxyName=mdef->name().copy();
+    if (!cname.isEmpty()) doxyName.prepend(cname+"::");
+    QCString doxyArgs=mdef->argsString();
+    ol.startDoxyAnchor(cfname,cname,mdef->anchor(),doxyName,doxyArgs);
+
+    ol.pushGeneratorState();
+    ol.disable(OutputGenerator::Man);
+    ol.disable(OutputGenerator::Latex);
+    ol.docify("\n");
+    ol.popGeneratorState();
+
+  }
+  // *** write type
+  /*VHDL CHANGE */
+  QCString ltype(mdef->typeString()); 
+  QCString largs(mdef->argsString());
+  int mm=mdef->getMemberSpecifiers();
+  //printf(":: ltype=%s largs=%s name=%s mm=%d\n",
+  //    ltype.data(),largs.data(),mdef->name().data(),mm);
+
+  ClassDef *kl=0;
+  //FileDef *fdd=0;
+  LockingPtr<ArgumentList> alp = mdef->argumentList();
+  QCString nn;
+  if (gd) gd=0;
+  switch(mm)
+  {
+    case VhdlDocGen::PROCEDURE:
+    case VhdlDocGen::FUNCTION: 
+      ol.startBold();
+      VhdlDocGen::formatString(ltype,ol,mdef);
+      ol.endBold();
+      ol.insertMemberAlign();
+      writeLink(mdef,ol);
+      if (alp!=0 && mm==VhdlDocGen::FUNCTION)
+	VhdlDocGen::writeFunctionProto(ol,alp.pointer(),mdef);
+
+      if (alp!=0 && mm==VhdlDocGen::PROCEDURE)
+	VhdlDocGen::writeProcedureProto(ol,alp.pointer(),mdef);
+
+      break;
+    case VhdlDocGen::GENERIC:
+    case VhdlDocGen::PORT:
+      writeLink(mdef,ol);
+      ol.insertMemberAlign();
+      if (mm==VhdlDocGen::GENERIC)
+      {
+	ol.startBold();
+	ol.docify(" ");
+	VhdlDocGen::formatString(ltype,ol,mdef);
+	ol.endBold();
+      }
+      else
+      {
+	ol.docify(" ");
+	ol.startBold();
+	ol.docify(mdef->typeString());
+	ol.endBold();
+	ol.docify(" ");
+	VhdlDocGen::formatString(largs,ol,mdef);
+      }
+      break;
+    case VhdlDocGen::PROCESS:
+      writeLink(mdef,ol);  
+      ol.insertMemberAlign();
+      VhdlDocGen::writeProcessProto(ol,alp.pointer(),mdef);
+      break;
+    case VhdlDocGen::PACKAGE:
+    case VhdlDocGen::ENTITY:
+    case VhdlDocGen::COMPONENT:
+      writeLink(mdef,ol);
+      ol.insertMemberAlign();
+      ol.docify(ltype);
+      ol.docify("  ");
+      if (VhdlDocGen::isComponent(mdef))
+      {
+	nn=mdef->name();
+	kl=getClass(nn.data());
+	if (kl) 
+	{
+	  nn=kl->getOutputFileBase();
+	  ol.pushGeneratorState();
+	  ol.disableAllBut(OutputGenerator::Html);
+	  ol.docify(" ");
+	  QCString name=theTranslator_vhdlType(VhdlDocGen::ENTITY,TRUE);
+	  ol.startBold();
+	  ol.docify(name.data());
+	  ol.endBold();
+	  ol.startEmphasis();
+	  name.resize(0);
+	  name+="  <"+mdef->name()+"> ";
+	  ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),0,name.data());
+	  ol.endEmphasis();
+	  ol.popGeneratorState();
+	}
+      } 
+      break;
+    case VhdlDocGen::USE:
+      kl=VhdlDocGen::getClass(mdef->name());
+      if (kl && ((VhdlDocGen::VhdlClasses)kl->protection()==VhdlDocGen::ENTITYCLASS)) break;
+      writeLink(mdef,ol);  
+      ol.insertMemberAlign();
+      ol.docify("  ");
+
+      if (kl)
+      {
+	nn=kl->getOutputFileBase();
+	ol.pushGeneratorState();
+	ol.disableAllBut(OutputGenerator::Html);
+	ol.docify(" ");
+	QCString name=theTranslator_vhdlType(VhdlDocGen::PACKAGE,TRUE);
+	ol.startBold();
+	ol.docify(name.data()); 
+	name.resize(0);
+	ol.endBold();
+	name+=" <"+mdef->name()+">";
+	ol.startEmphasis();
+	ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),0,name.data());
+	ol.popGeneratorState();
+      }
+      break;
+    case VhdlDocGen::LIBRARY:
+      writeLink(mdef,ol);
+      ol.insertMemberAlign();
+      break;
+    case VhdlDocGen::SIGNAL:
+    case VhdlDocGen::ATTRIBUTE:
+    case VhdlDocGen::TYPE:
+    case VhdlDocGen::SUBTYPE:
+    case VhdlDocGen::CONSTANT:      
+      writeLink(mdef,ol);
+      ol.docify(" ");
+      ol.insertMemberAlign();
+      VhdlDocGen::formatString(ltype,ol,mdef);
+      break;
+    case VhdlDocGen::RECORD:    
+      writeLink(mdef,ol);
+      ol.startBold();
+      if (ltype.isEmpty()) ol.docify("     : record");    
+      ol.insertMemberAlign();
+      if (!ltype.isEmpty()) 
+	VhdlDocGen::formatString(ltype,ol,mdef);
+      ol.endBold();
+      break;
+    case VhdlDocGen::UNITS:
+      ol.startBold();
+      writeLink(mdef,ol);
+      if (ltype.isEmpty()) ol.docify("     : unit");    
+      ol.insertMemberAlign();
+      if (!ltype.isEmpty())
+	VhdlDocGen::formatString(ltype,ol,mdef);
+      ol.endBold();    
+      break;
+    default: break;
+  }
+
+  bool htmlOn = ol.isEnabled(OutputGenerator::Html);
+  if (htmlOn && Config_getBool("HTML_ALIGN_MEMBERS") && !ltype.isEmpty())
+  {
+    ol.disable(OutputGenerator::Html);
+  }
+  if (!ltype.isEmpty()) ol.docify(" ");
+
+  if (htmlOn) 
+  {
+    ol.enable(OutputGenerator::Html);
+  }
+
+  if (!detailsVisible)// && !m_impl->annMemb)
+  {
+    ol.endDoxyAnchor(cfname,mdef->anchor());
+  }
+
+  //printf("endMember %s annoClassDef=%p annEnumType=%p\n",
+  //    name().data(),annoClassDef,annEnumType);
+  ol.endMemberItem();
+  if (!mdef->briefDescription().isEmpty() &&   Config_getBool("BRIEF_MEMBER_DESC") /* && !annMemb */)
+  {
+    ol.startMemberDescription();
+    ol.parseDoc(mdef->briefFile(),mdef->briefLine(),mdef->getOuterScope()?mdef->getOuterScope():d,mdef,mdef->briefDescription(),TRUE,FALSE);
+    if (detailsVisible) 
+    {
+      ol.pushGeneratorState();
+      ol.disableAllBut(OutputGenerator::Html);
+      //ol.endEmphasis();
+      ol.docify(" ");
+      if (mdef->getGroupDef()!=0 && gd==0) // forward link to the group
+      {
+	ol.startTextLink(mdef->getOutputFileBase(),mdef->anchor());
+      }
+      else // local link
+      {
+	ol.startTextLink(0,mdef->anchor());
+      }
+      ol.endTextLink();
+      //ol.startEmphasis();
+      ol.popGeneratorState();
+    }
+    //ol.newParagraph();
+    ol.endMemberDescription();
+  }
+  mdef->warnIfUndocumented();
+
+}// end writeVhdlDeclaration
+
+
+void VhdlDocGen::writeLink(const MemberDef* mdef,OutputList &ol) 
+{
+  ol.writeObjectLink(mdef->getReference(),
+                     mdef->getOutputFileBase(),
+		     mdef->anchor(),
+		     mdef->name());
+}
+
+void VhdlDocGen::writePlainVHDLDeclarations(
+    MemberList* mlist,OutputList &ol,
+    ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,int specifier)
+{
+
+  SDict<QCString> pack(1009);
+
+  ol.pushGeneratorState();
+
+  bool first=TRUE;
+  MemberDef *md;
+  MemberListIterator mli(*mlist);
+  for ( ; (md=mli.current()); ++mli )
+  { 
+    int mems=md->getMemberSpecifiers();
+    if (md->isBriefSectionVisible() && (mems==specifier) && (mems!=VhdlDocGen::LIBRARY) )
+    {
+      if (first) {ol.startMemberList();first=FALSE;}
+      VhdlDocGen::writeVHDLDeclaration(md,ol,cd,nd,fd,gd,FALSE);
+    } //if
+    else if (md->isBriefSectionVisible() && (mems==specifier))
+    {
+      if (!pack.find(md->name().data()))
+      {
+	if (first) ol.startMemberList(),first=FALSE;
+	VhdlDocGen::writeVHDLDeclaration(md,ol,cd,nd,fd,gd,FALSE);
+	pack.append(md->name().data(),new QCString(md->name().data()));
+      }
+    } //if
+  } //for
+  if (!first) ol.endMemberList(); 
+  pack.clear();
+}//plainDeclaration
+
+static bool membersHaveSpecificType(MemberList *ml,int type)
+{
+  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;
+}
+
+void VhdlDocGen::writeVHDLDeclarations(MemberList* ml,OutputList &ol,
+    ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
+    const char *title,const char *subtitle,bool /*showEnumValues*/,int type) 
+{
+
+  if (!membersHaveSpecificType(ml,type)) return;
+
+  if (title) 
+  {
+    ol.startMemberHeader();
+    ol.parseText(title);
+    ol.endMemberHeader();
+    ol.docify(" ");
+  }
+  if (subtitle && subtitle[0]!=0) 
+  {
+    ol.startMemberSubtitle();
+    ol.parseDoc("[generated]",-1,0,0,subtitle,FALSE,FALSE);
+    ol.endMemberSubtitle();
+  } //printf("memberGroupList=%p\n",memberGroupList);
+
+  VhdlDocGen::writePlainVHDLDeclarations(ml,ol,cd,nd,fd,gd,type);
+
+  if (ml->getMemberGroupList())
+  {
+    MemberGroupListIterator mgli(*ml->getMemberGroupList());
+    MemberGroup *mg;
+    while ((mg=mgli.current()))
+    {
+      if (membersHaveSpecificType(mg->members(),type))
+      {
+        //printf("mg->header=%s\n",mg->header().data());
+        bool hasHeader=mg->header()!="[NOHEADER]";
+        ol.startMemberGroupHeader(hasHeader);
+        if (hasHeader)
+        {
+          ol.parseText(mg->header());
+        }
+        ol.endMemberGroupHeader();
+        if (!mg->documentation().isEmpty())
+        {
+          //printf("Member group has docs!\n");
+          ol.startMemberGroupDocs();
+          ol.parseDoc("[generated]",-1,0,0,mg->documentation()+"\n",FALSE,FALSE);
+          ol.endMemberGroupDocs();
+        }
+        ol.startMemberGroup();
+        //printf("--- mg->writePlainDeclarations ---\n");
+        VhdlDocGen::writePlainVHDLDeclarations(mg->members(),ol,cd,nd,fd,gd,type);
+        ol.endMemberGroup(hasHeader);
+      }
+      ++mgli;
+    }
+  }
+}// writeVHDLDeclarations
+
+/* strips the prefix for record and unit members*/
+void VhdlDocGen::adjustRecordMember(MemberDef *mdef) 
+{ //,OutputList & ol) {
+  QRegExp regg("[_a-zA-Z]");
+  QCString nn=mdef->name();
+  int j=nn.find(regg,0);
+  if (j>0)
+  {
+    nn=nn.mid(j,nn.length());
+    mdef->setName(nn.data());
+  }
+}//adjustRecordMember
+
+/* strips the prefix for package and package body */
+
+bool VhdlDocGen::writeClassType( ClassDef *& cd,
+                                 OutputList &ol ,QCString & cname)
+{
+  //static ClassDef *prev = 0;
+  //if (prev == cd)  return TRUE;
+  //if (cd != prev) prev=cd;
+
+  int id=cd->protection();
+  QCString qcs = VhdlDocGen::trTypeString(id+2);
+  cname=VhdlDocGen::getClassName(cd);
+  ol.startBold();
+  ol.writeString(qcs.data());
+  ol.writeString(" ");
+  ol.endBold();
+  //ol.insertMemberAlign();
+  return FALSE;
+}// writeClassLink
+
+QCString VhdlDocGen::trVhdlType(int type,bool sing)
+{
+  switch(type)
+  {
+    case VhdlDocGen::LIBRARY:      
+      if (sing) return "Library";
+      else      return "Libraries"; 
+    case VhdlDocGen::PACKAGE:      
+      if (sing) return "Package";       
+      else      return "Packages";
+    case VhdlDocGen::SIGNAL:       
+      if (sing) return "Signal";        
+      else      return "Signals";
+    case VhdlDocGen::COMPONENT:    
+      if (sing) return "Component";     
+      else      return "Components";        
+    case VhdlDocGen::CONSTANT:     
+      if (sing) return "Constant";      
+      else      return "Constants";
+    case VhdlDocGen::ENTITY:       
+      if (sing) return "Entity";       
+      else      return "Entities";
+    case VhdlDocGen::TYPE:         
+      if (sing) return "Type";          
+      else      return "Types";
+    case VhdlDocGen::SUBTYPE:      
+      if (sing) return "Subtype";       
+      else      return "Subtypes";
+    case VhdlDocGen::FUNCTION:     
+      if (sing) return "Function";      
+      else      return "Functions";
+    case VhdlDocGen::RECORD:       
+      if (sing) return "Record";       
+      else      return "Records";
+    case VhdlDocGen::PROCEDURE:   
+      if (sing) return "Procedure";     
+      else      return "Procedures"; 
+    case VhdlDocGen::ARCHITECTURE: 
+      if (sing) return "Architecture";  
+      else      return "Architectures";
+    case VhdlDocGen::ATTRIBUTE:    
+      if (sing) return "Attribute";     
+      else      return "Attributes";
+    case VhdlDocGen::PROCESS:      
+      if (sing) return "Process";       
+      else      return "Processes";
+    case VhdlDocGen::PORT:         
+      if (sing) return "Port";          
+      else      return "Ports";
+    case VhdlDocGen::USE:          
+      if (sing) return "Package";       
+      else      return "Packages";
+    case VhdlDocGen::GENERIC:      
+      if (sing) return "Generic";       
+      else      return "Generics";
+    case VhdlDocGen::PACKAGE_BODY: 
+      return "Package Body";
+    case VhdlDocGen::DOCUMENT:     
+      return "Doc"; 
+    case VhdlDocGen::UNITS:        
+      return "Units"; 
+    default:                       
+      return "Class";
+  }
+}
+
+QCString VhdlDocGen::trDesignUnitHierarchy()
+{
+  return "Design Unit Hierarchy";
+}
+
+QCString VhdlDocGen::trDesignUnitList()
+{
+  return "Design Unit List";
+}
+
+QCString VhdlDocGen::trDesignUnitMembers()
+{
+  return "Design Unit Members";
+}
+
+QCString VhdlDocGen::trDesignUnitListDescription()
+{
+  return "Here is a list of all design unit members with links to "
+         "the Entities and Packages they belong to:"; 
+}
+
+QCString VhdlDocGen::trDesignUnitIndex()
+{
+  return "Design Unit Index";
+}
+
+QCString VhdlDocGen::trDesignUnits()
+{
+  return "Design Units";
+}
+
+QCString VhdlDocGen::trFunctionAndProc()
+{
+  return "Functions/Procedures/Processes";
+}
+
+
+
+/*! adds  documentation to a function/procedure */
+bool VhdlDocGen::writeDoc(EntryNav* rootNav)
+{
+  Entry *e=rootNav->entry();
+  //if (e->section==Entry::Entry::OVERLOADDOC_SEC) 
+  if (stricmp(e->type.data(),"function")==0)
+  {
+    VhdlDocGen::addFuncDoc(rootNav);     
+  }
+
+  return FALSE;
+}// writeDoc
+
+
+/* do not insert the same component twice */
+
+bool VhdlDocGen::foundInsertedComponent(const QCString & name,Entry* root)
+{
+  QListIterator<BaseInfo> bii(*root->extends);
+  BaseInfo *bi=0;
+  for (bii.toFirst();(bi=bii.current());++bii) 
+  {
+    if (bi->name==name)
+    {
+      return TRUE; // 
+    }
+  }
+
+  return FALSE;
+}// found component
+
+/*! writes a link if the string is linkable else a formatted string */
+
+void VhdlDocGen::writeStringLink(const MemberDef *mdef,QCString mem, OutputList& ol)
+{
+  if (mdef) 
+  {
+    ClassDef *cd=mdef->getClassDef();
+    if (cd)
+    { 
+      QCString n=cd->name(); 
+      MemberDef* memdef=VhdlDocGen::findMember(n,mem);
+      if (memdef && memdef->isLinkable()) 
+      { 
+	ol.startBold();
+	writeLink(memdef,ol);                
+	ol.endBold();
+	ol.docify(" ");
+	return;
+      }
+    }
+  }
+  VhdlDocGen::startFonts(mem,"vhdlchar",ol);    
+}// found component
+