diff options
author | Dimitri van Heesch <dimitri@stack.nl> | 2008-01-17 18:56:38 (GMT) |
---|---|---|
committer | Dimitri van Heesch <dimitri@stack.nl> | 2008-01-17 18:56:38 (GMT) |
commit | f1103ed882b5739e7f16cfd69527bde6d6d96dfa (patch) | |
tree | 05e55417a750c1275c9139b7952de6941db168dd /src/vhdldocgen.cpp | |
parent | c9fcb1845bd7c5080abfee1be4070130bbdd38c2 (diff) | |
download | Doxygen-f1103ed882b5739e7f16cfd69527bde6d6d96dfa.zip Doxygen-f1103ed882b5739e7f16cfd69527bde6d6d96dfa.tar.gz Doxygen-f1103ed882b5739e7f16cfd69527bde6d6d96dfa.tar.bz2 |
Release-1.5.4-20080101
Diffstat (limited to 'src/vhdldocgen.cpp')
-rw-r--r-- | src/vhdldocgen.cpp | 2319 |
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 + |