VhdlDocGen Class Reference

Class for generating documentation specific for VHDL. More...

#include <src/vhdldocgen.h>

Public Types
enum	VhdlClasses { ENTITYCLASS , PACKBODYCLASS , ARCHITECTURECLASS , PACKAGECLASS }

Static Public Member Functions
static VhdlClasses	convert (Protection prot)
static void	init ()
static DString	convertFileNameToClassName (const DString &name)
static bool	isSubClass (ClassDef *cd, ClassDef *scd, bool followInstances, int level)
static DString	getIndexWord (const DString &, int index)
static bool	deleteCharRev (DString &s, char c)
static void	deleteAllChars (DString &s, char c)
static void	parseFuncProto (const DString &text, DString &name, DString &ret, bool doc=false)
static void	computeVhdlComponentRelations ()
static const char *	findKeyWord (const DString &word)
static ClassDef *	getPackageName (const DString &name)
static const MemberDef *	findMember (const DString &className, const DString &memName)
static void	findAllPackages (ClassDef *)
static const MemberDef *	findMemberDef (ClassDef *cd, const DString &key, MemberListType type)
	This function returns the entity|package in which the key (type) is found.
static ClassDef *	getClass (const DString &name)
static const MemberDef *	findFunction (const DString &name, const DString &package)
static DString	getClassTitle (const ClassDef *)
static void	writeInlineClassLink (const ClassDef *, OutputList &ol)
static void	writeTagFile (MemberDefMutable *mdef, TextStream &tagFile)
static bool	isConstraint (const MemberDef *mdef)
static bool	isConfig (const MemberDef *mdef)
static bool	isAlias (const MemberDef *mdef)
static bool	isLibrary (const MemberDef *mdef)
static bool	isGeneric (const MemberDef *mdef)
static bool	isPort (const MemberDef *mdef)
static bool	isComponent (const MemberDef *mdef)
static bool	isPackage (const MemberDef *mdef)
static bool	isEntity (const MemberDef *mdef)
static bool	isConstant (const MemberDef *mdef)
static bool	isVType (const MemberDef *mdef)
static bool	isSubType (const MemberDef *mdef)
static bool	isVhdlFunction (const MemberDef *mdef)
static bool	isProcess (const MemberDef *mdef)
static bool	isSignal (const MemberDef *mdef)
static bool	isAttribute (const MemberDef *mdef)
static bool	isSignals (const MemberDef *mdef)
static bool	isProcedure (const MemberDef *mdef)
static bool	isRecord (const MemberDef *mdef)
static bool	isArchitecture (const MemberDef *mdef)
static bool	isUnit (const MemberDef *mdef)
static bool	isPackageBody (const MemberDef *mdef)
static bool	isVariable (const MemberDef *mdef)
static bool	isFile (const MemberDef *mdef)
static bool	isGroup (const MemberDef *mdef)
static bool	isCompInst (const MemberDef *mdef)
static bool	isMisc (const MemberDef *mdef)
static void	prepareComment (DString &)
static void	formatString (const DString &, OutputList &ol, const MemberDef *)
static void	writeFormatString (const DString &, OutputList &ol, const MemberDef *)
static void	writeFunctionProto (OutputList &ol, const ArgumentList &al, const MemberDef *)
static void	writeProcessProto (OutputList &ol, const ArgumentList &al, const MemberDef *)
static void	writeProcedureProto (OutputList &ol, const ArgumentList &al, const MemberDef *)
static bool	writeFuncProcDocu (const MemberDef *mdef, OutputList &ol, const ArgumentList &al, bool type=false)
static void	writeRecordProto (const MemberDef *mdef, OutputList &ol, const ArgumentList &al)
static bool	writeVHDLTypeDocumentation (const MemberDef *mdef, const Definition *d, OutputList &ol)
static void	writeVhdlDeclarations (const MemberList *, OutputList &, const GroupDef *, const ClassDef *, const FileDef *, const NamespaceDef *, const ModuleDef *)
static void	writeVHDLDeclaration (MemberDefMutable *mdef, OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool inGroup)
static void	writePlainVHDLDeclarations (const MemberList *ml, OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, VhdlSpecifier specifier)
static void	writeVHDLDeclarations (const MemberList *ml, OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, const DString &title, const DString &subtitle, bool showEnumValues, VhdlSpecifier type)
static bool	writeClassType (const ClassDef *, OutputList &ol, DString &cname)
static DString	convertArgumentListToString (const ArgumentList &al, bool f)
static DString	getProcessNumber ()
static DString	getRecordNumber ()
static DString	getClassName (const ClassDef *)
static bool	isNumber (const std::string &s)
static DString	getProtectionName (int prot)
static void	parseUCF (const DString &input, Entry *entity, const DString &f, bool vendor)
static const ClassDef *	findArchitecture (const ClassDef *cd)
static void	correctMemberProperties (MemberDefMutable *md)
static void	writeSource (const MemberDef *mdef, OutputList &ol, const DString &cname)
static DString	parseForConfig (DString &entity, DString &arch)
static DString	parseForBinding (DString &entity, DString &arch)
static void	addBaseClass (ClassDef *cd, ClassDef *ent)
static ClassDef *	findVhdlClass (const DString &className)
static void	createFlowChart (const MemberDef *)
static void	setFlowMember (const MemberDef *flowMember)
static const MemberDef *	getFlowMember ()
static bool	isVhdlClass (const Entry *cu)
static void	resetCodeVhdlParserState ()

Static Private Member Functions
static void	findAllArchitectures (std::vector< DString > &ql, const ClassDef *cd)
static bool	compareArgList (const ArgumentList &, const ArgumentList &)
static void	writeVhdlLink (const ClassDef *cdd, OutputList &ol, DString &type, DString &name, DString &beh)
static void	writeStringLink (const MemberDef *mdef, DString mem, OutputList &ol)
static void	writeRecUnitDocu (const MemberDef *md, OutputList &ol, DString largs)
static void	writeRecordUnit (DString &largs, DString &ltype, OutputList &ol, MemberDefMutable *mdef)

Detailed Description

Class for generating documentation specific for VHDL.

Definition at line 69 of file vhdldocgen.h.

Member Enumeration Documentation

VhdlClasses

enum VhdlDocGen::VhdlClasses

Enumerator
ENTITYCLASS
PACKBODYCLASS
ARCHITECTURECLASS
PACKAGECLASS

Definition at line 73 of file vhdldocgen.h.

    {
      ENTITYCLASS,         // Overlays: Public
      PACKBODYCLASS,       // Overlays: Protected
      ARCHITECTURECLASS,   // Overlays: Private
      PACKAGECLASS         // Overlays: Package
    };

Member Function Documentation

addBaseClass()

void VhdlDocGen::addBaseClass ( ClassDef * cd, ClassDef * ent )

static

Definition at line 2347 of file vhdldocgen.cpp.

{
  BaseClassList bcl = cd->baseClasses();
  for (auto &bcd : bcl)
  {
    ClassDef *ccd = bcd.classDef;
    if (ccd==ent)
    {
      DString n = bcd.usedName;
      size_t i = n.find('(');
      if (i==DString::npos)
      {
        bcd.usedName.append("(2)");
        return;
      }
      static const reg::Ex reg(R"(\d+)");
      DString s=n.left(i);
      DString r=n.mid(i);
      std::string t=r.str();
      VhdlDocGen::deleteAllChars(r,')');
      VhdlDocGen::deleteAllChars(r,'(');
      r.setNum(r.toInt()+1);
      reg::replace(t, reg, r.str());
      s.append(t);
      bcd.usedName=s;
      bcd.templSpecifiers=t;
    }
  }
  cd->updateBaseClasses(bcl);
}

References DString::append(), ClassDef::baseClasses(), deleteAllChars(), DString::find(), DString::left(), DString::mid(), DString::npos, reg::replace(), DString::setNum(), DString::str(), DString::toInt(), and ClassDef::updateBaseClasses().

Referenced by addInstance(), and writeRecordProto().

compareArgList()

bool VhdlDocGen::compareArgList ( const ArgumentList & , const ArgumentList &  )

staticprivate

References writeRecordUnit(), writeRecUnitDocu(), writeStringLink(), and writeVhdlLink().

computeVhdlComponentRelations()

void VhdlDocGen::computeVhdlComponentRelations ( )

static

Definition at line 2146 of file vhdldocgen.cpp.

{
 
  DString entity,arch,inst;
 
  for (const auto &cur : getVhdlInstList())
  {
    if (cur->isStatic ) //  was bind
    {
      continue;
    }
 
    if (cur->includeName=="entity" || cur->includeName=="component" )
    {
      entity=cur->includeName+" "+cur->type;
      DString rr=VhdlDocGen::parseForBinding(entity,arch);
    }
    else if (cur->includeName.empty())
    {
      entity=cur->type;
    }
 
    ClassDefMutable *classEntity= toClassDefMutable(VhdlDocGen::findVhdlClass(entity));
    inst=VhdlDocGen::getIndexWord(cur->args,0);
    ClassDefMutable *cd=toClassDefMutable(Doxygen::classLinkedMap->find(inst));
    ClassDefMutable *ar=toClassDefMutable(Doxygen::classLinkedMap->find(cur->args));
 
    if (cd==nullptr)
    {
      continue;
    }
 
    addInstance(classEntity,ar,cd,cur);
  }
 
}

References addInstance(), Doxygen::classLinkedMap, findVhdlClass(), getIndexWord(), getVhdlInstList(), parseForBinding(), and toClassDefMutable().

Referenced by parseInput().

convert()

VhdlClasses VhdlDocGen::convert ( Protection prot )

inlinestatic

Definition at line 80 of file vhdldocgen.h.

    {
      switch (prot)
      {
        case Protection::Public:    return ENTITYCLASS;
        case Protection::Protected: return PACKBODYCLASS;
        case Protection::Private:   return ARCHITECTURECLASS;
        case Protection::Package:   return PACKAGECLASS;
      }
      return ENTITYCLASS;
    }

References ARCHITECTURECLASS, ENTITYCLASS, PACKAGECLASS, and PACKBODYCLASS.

Referenced by DotGfxHierarchyTable::addClassList(), findMember(), getClassName(), getSpecifierTypeFromClass(), ClassDefImpl::setProtection(), writeAlphabeticalClassList(), writeAnnotatedClassList(), writeClassTree(), writeClassTreeForList(), writeClassTreeToOutput(), ClassDefImpl::writeDeclarationLink(), writeInlineClassLink(), and writeVHDLDeclaration().

convertArgumentListToString()

DString VhdlDocGen::convertArgumentListToString ( const ArgumentList & al, bool f )

static

Definition at line 1153 of file vhdldocgen.cpp.

{
  DString argString;
  bool sem=false;
 
  for (const Argument &arg : al)
  {
    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;
}

References DString::append().

Referenced by writeRecordProto(), and writeTagFile().

convertFileNameToClassName()

DString VhdlDocGen::convertFileNameToClassName ( const DString & name )

static

Definition at line 1904 of file vhdldocgen.cpp.

{
  DString n=name;
  n=n.remove(0,6);
  size_t i=0;
  while ((i=n.find("__"))!=DString::npos && i>0) n=n.remove(i,1);
  while ((i=n.find("_1"))!=DString::npos && i>0) n=n.replace(i,2,":");
  return n;
}

References DString::find(), DString::npos, DString::remove(), and DString::replace().

correctMemberProperties()

void VhdlDocGen::correctMemberProperties ( MemberDefMutable * md )

static

Definition at line 1211 of file vhdldocgen.cpp.

{
  if (md->argsString()=="package")
  {
    md->setVhdlSpecifiers(VhdlSpecifier::INSTANTIATION);
  }
  else if (md->argsString()=="configuration")
  {
    md->setVhdlSpecifiers(VhdlSpecifier::CONFIG);
  }
  else if (md->typeString()=="library")
  {
    md->setVhdlSpecifiers(VhdlSpecifier::LIBRARY);
  }
  else if (md->typeString()=="use")
  {
    md->setVhdlSpecifiers(VhdlSpecifier::USE);
  }
  else if (md->typeString().lower()=="misc")
  {
    md->setVhdlSpecifiers(VhdlSpecifier::MISCELLANEOUS);
  }
  else if (md->typeString().lower()=="ucf_const")
  {
    md->setVhdlSpecifiers(VhdlSpecifier::UCF_CONST);
  }
 
  if (md->getVhdlSpecifiers()==VhdlSpecifier::UCF_CONST)
  {
    size_t mm=md->name().rfind('_');
    if (mm!=DString::npos && mm>0)
    {
      md->setName(md->name().left(mm));
    }
  }
  else if (md->getVhdlSpecifiers()==VhdlSpecifier::TYPE)
  {
    DString largs=md->argsString();
    bool bRec=largs.stripPrefix("record") ;
    bool bUnit=largs.stripPrefix("units") ;
    if (bRec || bUnit)
    {
      md->setType("");
    }
  }
}

References MemberDef::argsString(), CONFIG, MemberDef::getVhdlSpecifiers(), INSTANTIATION, DString::left(), LIBRARY, DString::lower(), MISCELLANEOUS, Definition::name(), DString::npos, DString::rfind(), DefinitionMutable::setName(), MemberDefMutable::setType(), MemberDefMutable::setVhdlSpecifiers(), DString::stripPrefix(), TYPE, MemberDef::typeString(), UCF_CONST, and USE.

Referenced by vhdlCorrectMemberProperties(), and writeRecordProto().

createFlowChart()

void VhdlDocGen::createFlowChart ( const MemberDef * mdef )

static

Definition at line 2393 of file vhdldocgen.cpp.

{
  if (mdef==nullptr) return;
 
  DString codeFragment;
  const MemberDef* mm=nullptr;
  if ((mm=findMemFlow(mdef))!=nullptr)
  {
    // don't create the same flowchart twice
    VhdlDocGen::setFlowMember(mm);
    return;
  }
  else
  {
    mdList.push_back(mdef);
  }
 
  //fprintf(stderr,"\n create flow mem %s %p\n",qPrint(mdef->name()),mdef);
 
  int actualStart= mdef->getStartBodyLine();
  int actualEnd=mdef->getEndBodyLine();
  const FileDef* fd=mdef->getFileDef();
  bool b=readCodeFragment( fd->absFilePath(), false, actualStart, actualEnd, codeFragment);
  if (!b) return;
 
  auto parser { Doxygen::parserManager->getOutlineParser(".vhd") };
  VhdlDocGen::setFlowMember(mdef);
  std::shared_ptr<Entry> root = std::make_shared<Entry>();
  StringVector filesInSameTu;
  parser->parseInput("",codeFragment.data(),root,nullptr);
}

References FileDef::absFilePath(), DString::data(), findMemFlow(), Definition::getEndBodyLine(), MemberDef::getFileDef(), ParserManager::getOutlineParser(), Definition::getStartBodyLine(), mdList, Doxygen::parserManager, readCodeFragment(), and setFlowMember().

Referenced by DocVhdlFlow::parse(), and writeRecordProto().

deleteAllChars()

void VhdlDocGen::deleteAllChars ( DString & s, char c )

static

Definition at line 724 of file vhdldocgen.cpp.

{
  size_t index=s.rfind_insensitive(c);
  while (index!=DString::npos)
  {
    s = s.remove(index,1);
    index=s.rfind_insensitive(c);
  }
}

References DString::npos, DString::remove(), and DString::rfind_insensitive().

Referenced by addBaseClass(), VHDLOutlineParser::createFunction(), and initUCF().

deleteCharRev()

bool VhdlDocGen::deleteCharRev ( DString & s, char c )

static

deletes a char backwards in a string

Definition at line 713 of file vhdldocgen.cpp.

{
  size_t index=s.rfind_insensitive(c);
  if (index!=DString::npos)
  {
    s = s.remove(index,1);
    return true;
  }
  return false;
}

References DString::npos, DString::remove(), and DString::rfind_insensitive().

Referenced by parseFuncProto().

findAllArchitectures()

void VhdlDocGen::findAllArchitectures ( std::vector< DString > & ql, const ClassDef * cd )

staticprivate

Definition at line 530 of file vhdldocgen.cpp.

{
  for (const auto &citer : *Doxygen::classLinkedMap)
  {
    DString className=citer->className();
    size_t pos = DString::npos;
    if (cd != citer.get() && (pos=className.find('-'))!=DString::npos)
    {
      DString postfix=className.mid(pos+1);
      if (dstricmp(cd->className(),postfix)==0)
      {
        qll.push_back(className);
      }
    }
  }// for
}//findAllArchitectures

References Doxygen::classLinkedMap, ClassDef::className(), dstricmp(), DString::find(), DString::mid(), and DString::npos.

Referenced by writeInlineClassLink().

findAllPackages()

void VhdlDocGen::findAllPackages ( ClassDef * cdef )

static

finds all included packages of an Entity or Package

Definition at line 360 of file vhdldocgen.cpp.

{
  std::lock_guard lock(g_vhdlMutex);
  if (g_packages.find(cdef)!=g_packages.end()) return;
  std::vector<ClassDef*> cList;
  MemberList *mem=cdef->getMemberList(MemberListType::VariableMembers());
  if (mem)
  {
    for (const auto &md : *mem)
    {
      if (VhdlDocGen::isPackage(md))
      {
        ClassDef* cd=VhdlDocGen::getPackageName(md->name());
        if (cd)
        {
          cList.push_back(cd);
          VhdlDocGen::findAllPackages(cd);
          g_packages.emplace(cdef,cList);
        }
      }
    }//for
  }
 
}// findAllPackages

References findAllPackages(), g_packages, g_vhdlMutex, ClassDef::getMemberList(), getPackageName(), and isPackage().

Referenced by findAllPackages(), and findMember().

findArchitecture()

const ClassDef * VhdlDocGen::findArchitecture ( const ClassDef * cd )

static

Definition at line 547 of file vhdldocgen.cpp.

{
  for (const auto &citer : *Doxygen::classLinkedMap)
  {
    DString jj=citer->name();
    StringVector ql=split(jj.str(),":");
    if (ql.size()>1)
    {
      if (ql[0]==cd->name())
      {
        return citer.get();
      }
    }
  }
  return nullptr;
}

References Doxygen::classLinkedMap, Definition::name(), split(), and DString::str().

Referenced by writeRecordProto().

findFunction()

const MemberDef * VhdlDocGen::findFunction ( const DString & funcname, const DString & package )

static

returns the function with the matching argument list is called in vhdlcode.l

Definition at line 390 of file vhdldocgen.cpp.

{
  ClassDef *cdef=getClass(package);
  if (cdef==nullptr) return nullptr;
 
  MemberList *mem=cdef->getMemberList(MemberListType::PubMethods());
  if (mem)
  {
    for (const auto &mdef : *mem)
    {
      DString mname=mdef->name();
      if ((VhdlDocGen::isProcedure(mdef) || VhdlDocGen::isVhdlFunction(mdef)) && (compareString(funcname,mname)==0))
      {
        return mdef;
      }//if
    }//for
  }//if
  return nullptr;
} //findFunction

References compareString(), getClass(), ClassDef::getMemberList(), isProcedure(), and isVhdlFunction().

Referenced by writeFuncProto().

findKeyWord()

const char * VhdlDocGen::findKeyWord ( const DString & kw )

static

returns the color of a keyword

Definition at line 178 of file vhdldocgen.cpp.

{
  std::string word=kw.lower().str();
 
  if (word.empty()) return nullptr;
 
  if (g_vhdlKeyWordSet0.find(word)!=g_vhdlKeyWordSet0.end())
    return "keywordflow";
 
  if (g_vhdlKeyWordSet1.find(word)!=g_vhdlKeyWordSet1.end())
    return "keywordtype";
 
  if (g_vhdlKeyWordSet2.find(word)!=g_vhdlKeyWordSet2.end())
    return "vhdllogic";
 
  if (g_vhdlKeyWordSet3.find(word)!=g_vhdlKeyWordSet3.end())
    return "vhdlkeyword";
 
  return nullptr;
}

References g_vhdlKeyWordSet0, g_vhdlKeyWordSet1, g_vhdlKeyWordSet2, g_vhdlKeyWordSet3, DString::lower(), and DString::str().

Referenced by writeColoredWord(), writeFormatString(), writeFunctionProto(), and writeProcedureProto().

findMember()

const MemberDef * VhdlDocGen::findMember ( const DString & className, const DString & memName )

static

Definition at line 215 of file vhdldocgen.cpp.

{
  std::lock_guard lock(g_vhdlMutex);
  ClassDef *ecd=nullptr;
  const MemberDef *mdef=nullptr;
 
  ClassDef *cd=getClass(className);
  //printf("VhdlDocGen::findMember(%s,%s)=%p\n",qPrint(className),qPrint(memName),cd);
  if (cd==nullptr) return nullptr;
 
  mdef=VhdlDocGen::findMemberDef(cd,memName,MemberListType::VariableMembers());
  if (mdef) return mdef;
  mdef=VhdlDocGen::findMemberDef(cd,memName,MemberListType::PubMethods());
  if (mdef) return mdef;
 
  // nothing found so far
  // if we are an architecture or package body search in entity
 
  if (VhdlDocGen::convert(cd->protection())==VhdlDocGen::ARCHITECTURECLASS ||
      VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKBODYCLASS)
  {
    Definition *d = cd->getOuterScope();
    // searching upper/lower case names
 
    DString tt=d->name();
    ecd =getClass(tt);
    if (!ecd)
    {
      tt=tt.upper();
      ecd =getClass(tt);
    }
    if (!ecd)
    {
      tt=tt.lower();
      ecd =getClass(tt);
    }
 
    if (ecd) //d && d->definitionType()==Definition::TypeClass)
    {
      //ClassDef *ecd = (ClassDef*)d;
      mdef=VhdlDocGen::findMemberDef(ecd,memName,MemberListType::VariableMembers());
      if (mdef) return mdef;
      mdef=VhdlDocGen::findMemberDef(cd,memName,MemberListType::PubMethods());
      if (mdef) return mdef;
    }
   }
 
 
  if (VhdlDocGen::convert(cd->protection())==VhdlDocGen::ARCHITECTURECLASS ||
      VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKBODYCLASS)
  {
    Definition *d = cd->getOuterScope();
 
    DString tt=d->name();
    ClassDef *acd =getClass(tt);
    if (!acd)
    {
      tt=tt.upper();
      acd =getClass(tt);
    }
    if (!acd)
    {
      tt=tt.lower();
      acd =getClass(tt);
    }
    if (acd) //d && d->definitionType()==Definition::TypeClass)
    {
      if(g_packages.find(acd)==g_packages.end())
      {
        VhdlDocGen::findAllPackages(acd);
      }
    }
  }
  else
  {
    ecd=cd;
    if (g_packages.find(ecd)==g_packages.end()) VhdlDocGen::findAllPackages(ecd);
  }
 
  if (ecd)
  {
    auto cList_it = g_packages.find(ecd);
    if (cList_it!=g_packages.end())
    {
      for (const auto &cdp : cList_it->second)
      {
        mdef=VhdlDocGen::findMemberDef(cdp,memName,MemberListType::VariableMembers());
        if (mdef) return mdef;
        mdef=VhdlDocGen::findMemberDef(cdp,memName,MemberListType::PubMethods());
        if (mdef) return mdef;
      }
    }
  }
  return nullptr;
 
}//findMember

References ARCHITECTURECLASS, convert(), findAllPackages(), findMemberDef(), g_packages, g_vhdlMutex, getClass(), Definition::getOuterScope(), DString::lower(), Definition::name(), PACKBODYCLASS, ClassDef::protection(), and DString::upper().

Referenced by generateMemLink(), startCodeLine(), writeStringLink(), and writeVHDLTypeDocumentation().

findMemberDef()

const MemberDef * VhdlDocGen::findMemberDef ( ClassDef * cd, const DString & key, MemberListType type )

static

This function returns the entity|package in which the key (type) is found.

Definition at line 316 of file vhdldocgen.cpp.

{
  std::lock_guard lock(g_vhdlMutex);
  DString keyType=cd->symbolName()+"@"+key;
  //printf("\n %s | %s | %s",qPrint(cd->symbolName()),key.data(,),qPrint(keyType));
 
  auto it = g_varMap.find(keyType.str());
  if (it!=g_varMap.end())
  {
    return it->second;
  }
  if (std::find(g_classList.begin(),g_classList.end(),cd)!=g_classList.end())
  {
    return nullptr;
  }
  const MemberList *ml=cd->getMemberList(type);
  g_classList.push_back(cd);
  if (!ml)
  {
    return nullptr;
  }
  //int l=ml->count();
  //    fprintf(stderr,"\n loading entity %s %s: %d",qPrint(cd->symbolName()),qPrint(keyType),l);
 
  for (const auto &md : *ml)
  {
    DString tkey=cd->symbolName()+"@"+md->name();
    if (g_varMap.find(tkey.str())==g_varMap.end())
    {
      g_varMap.emplace(tkey.str(),md);
    }
  }
  it=g_varMap.find(keyType.str());
  if (it!=g_varMap.end())
  {
    return it->second;
  }
  return nullptr;
}//findMemberDef

References g_classList, g_varMap, g_vhdlMutex, ClassDef::getMemberList(), DString::str(), and Definition::symbolName().

Referenced by findMember().

findVhdlClass()

ClassDef * VhdlDocGen::findVhdlClass ( const DString & className )

static

Definition at line 2120 of file vhdldocgen.cpp.

{
 for (const auto &cd : *Doxygen::classLinkedMap)
 {
   if (dstricmp(className.data(),qPrint(cd->name()))==0)
   {
     return cd.get();
   }
 }
 return nullptr;
}

References Doxygen::classLinkedMap, DString::data(), dstricmp(), and qPrint().

Referenced by computeVhdlComponentRelations(), and writeRecordProto().

formatString()

void VhdlDocGen::formatString ( const DString & s, OutputList & ol, const MemberDef * mdef )

static

inserts white spaces for better readings and writes a colored string to the output

Definition at line 848 of file vhdldocgen.cpp.

{
  DString qcs = s;
  DString temp;
  qcs.stripPrefix(":");
  qcs.stripPrefix("is");
  qcs.stripPrefix("IS");
  qcs.stripPrefix("of");
  qcs.stripPrefix("OF");
 
  size_t len = qcs.length();
  size_t index=1;
 
  for (size_t 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==']' ) // || (c==':' && b!='=')) // || (c=='=' && b!='>'))
    {
      if (temp.length()>=index && temp.at(index-1) != ' ')
      {
        temp+=" ";
      }
      temp+=c;
      temp+=" ";
    }
    else if (c=='=')
    {
      if (b==':') // := operator
      {
        temp.replace(index-1,1,"=");
        temp+=" ";
      }
      else // = operator
      {
        temp+=" ";
        temp+=c;
        temp+=" ";
      }
    }
    else
    {
      temp+=c;
    }
 
    index=temp.length();
  }// for
  temp=temp.stripWhiteSpace();
  // printf("\n [%s]",qPrint(qcs));
  VhdlDocGen::writeFormatString(temp,ol,mdef);
}

References DString::at(), DString::length(), DString::replace(), DString::stripPrefix(), DString::stripWhiteSpace(), and writeFormatString().

Referenced by writeFunctionProto(), writeProcedureProto(), writeRecordUnit(), writeRecUnitDocu(), writeUCFLink(), writeVHDLDeclaration(), and writeVHDLTypeDocumentation().

getClass()

ClassDef * VhdlDocGen::getClass ( const DString & name )

static

Definition at line 199 of file vhdldocgen.cpp.

{
  if (name.empty()) return nullptr;
  return Doxygen::classLinkedMap->find(DString(name).stripWhiteSpace());
}

References Doxygen::classLinkedMap, DString::DString(), DString::empty(), LinkedMap< T, Hash, KeyEqual, Map >::find(), and stripWhiteSpace().

Referenced by findFunction(), findMember(), generateMemLink(), getPackageName(), writeInlineClassLink(), and writeVHDLDeclaration().

getClassName()

DString VhdlDocGen::getClassName ( const ClassDef * cd )

static

Definition at line 444 of file vhdldocgen.cpp.

{
  DString temp;
  if (cd==nullptr) return "";
 
  if (VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKBODYCLASS)
  {
    temp=cd->name();
    temp.stripPrefix("_");
    return temp;
  }
 
  return substitute(cd->className(),"::",".");
}

References ClassDef::className(), convert(), Definition::name(), PACKBODYCLASS, ClassDef::protection(), DString::stripPrefix(), and substitute().

Referenced by getClassTitle(), makeDisplayName(), writeClassType(), and writeRecordProto().

getClassTitle()

DString VhdlDocGen::getClassTitle ( const ClassDef * cd )

static

returns the class title+ref

Definition at line 432 of file vhdldocgen.cpp.

{
  DString pageTitle;
  if (cd==nullptr) return "";
  pageTitle=VhdlDocGen::getClassName(cd);
  pageTitle+=" ";
  pageTitle+=theTranslator_vhdlType(getSpecifierTypeFromClass(cd),true);
  return pageTitle;
} // getClassTitle

References getClassName(), getSpecifierTypeFromClass(), and theTranslator_vhdlType.

Referenced by ClassDefImpl::title().

getFlowMember()

const MemberDef * VhdlDocGen::getFlowMember ( )

static

Definition at line 80 of file vhdldocgen.cpp.

{
  return flowMember;
}

References flowMember.

Referenced by FlowChart::addFlowChart(), VHDLOutlineParser::addVhdlType(), FlowChart::alignFuncProc(), FlowChart::convertNameToFileName(), VHDLOutlineParser::createFlow(), VHDLOutlineParser::handleFlowComment(), FlowChart::moveToPrevLevel(), HtmlDocVisitor::operator()(), and writeRecordProto().

getIndexWord()

DString VhdlDocGen::getIndexWord ( const DString & c, int index )

static

Definition at line 681 of file vhdldocgen.cpp.

{
  static const reg::Ex reg(R"([\s:|])");
  auto ql=split(c.str(),reg);
 
  if (index < static_cast<int>(ql.size()))
  {
    return ql[index];
  }
 
  return "";
}

References split(), and DString::str().

Referenced by computeVhdlComponentRelations(), and parseFuncProto().

getPackageName()

ClassDef * VhdlDocGen::getPackageName ( const DString & name )

static

Definition at line 205 of file vhdldocgen.cpp.

{
  return getClass(name);
}

References getClass().

Referenced by findAllPackages().

getProcessNumber()

DString VhdlDocGen::getProcessNumber ( )

static

returns the next number of an anonymous process

Definition at line 753 of file vhdldocgen.cpp.

{
  static int stringCounter;
  DString qcs("PROCESS_");
  char buf[8];
  snprintf(buf,8,"%d",stringCounter++);
  qcs.append(&buf[0]);
  return qcs;
}

References DString::append().

Referenced by writeRecordProto().

getProtectionName()

DString VhdlDocGen::getProtectionName ( int prot )

static

Definition at line 695 of file vhdldocgen.cpp.

{
  if (prot==VhdlDocGen::ENTITYCLASS)
    return "entity";
  else if (prot==VhdlDocGen::ARCHITECTURECLASS)
    return "architecture";
  else if (prot==VhdlDocGen::PACKAGECLASS)
    return "package";
  else if (prot==VhdlDocGen::PACKBODYCLASS)
    return "package body";
 
  return "";
}

References ARCHITECTURECLASS, ENTITYCLASS, PACKAGECLASS, and PACKBODYCLASS.

Referenced by writeAnnotatedClassList(), ClassDefImpl::writeDeclarationLink(), and writeRecordProto().

getRecordNumber()

DString VhdlDocGen::getRecordNumber ( )

static

returns the next number of a record|unit member

Definition at line 741 of file vhdldocgen.cpp.

{
  char buf[12];
  snprintf(buf,12,"%d",recordCounter++);
  DString qcs(&buf[0]);
  return qcs;
}

References recordCounter.

Referenced by VHDLOutlineParser::checkInlineCode(), initUCF(), and writeRecordProto().

init()

void VhdlDocGen::init ( )

static

Definition at line 171 of file vhdldocgen.cpp.

{
}

Referenced by VHDLCodeParser::parseCode().

isAlias()

bool VhdlDocGen::isAlias ( const MemberDef * mdef )

static

Definition at line 2437 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::ALIAS; }

References ALIAS, and MemberDef::getVhdlSpecifiers().

Referenced by writeTagFile().

isArchitecture()

bool VhdlDocGen::isArchitecture ( const MemberDef * mdef )

static

Definition at line 2471 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::ARCHITECTURE; }

References ARCHITECTURE, and MemberDef::getVhdlSpecifiers().

isAttribute()

bool VhdlDocGen::isAttribute ( const MemberDef * mdef )

static

Definition at line 2463 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::ATTRIBUTE; }

References ATTRIBUTE, and MemberDef::getVhdlSpecifiers().

Referenced by writeTagFile().

isCompInst()

bool VhdlDocGen::isCompInst ( const MemberDef * mdef )

static

Definition at line 2483 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::INSTANTIATION; }

References MemberDef::getVhdlSpecifiers(), and INSTANTIATION.

Referenced by writeTagFile(), and writeVHDLDeclaration().

isComponent()

bool VhdlDocGen::isComponent ( const MemberDef * mdef )

static

Definition at line 2445 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::COMPONENT; }

References COMPONENT, and MemberDef::getVhdlSpecifiers().

Referenced by writeTagFile(), and writeVHDLDeclaration().

isConfig()

bool VhdlDocGen::isConfig ( const MemberDef * mdef )

static

Definition at line 2435 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::CONFIG; }

References CONFIG, and MemberDef::getVhdlSpecifiers().

Referenced by writeVHDLDeclaration().

isConstant()

bool VhdlDocGen::isConstant ( const MemberDef * mdef )

static

Definition at line 2451 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::CONSTANT; }

References CONSTANT, and MemberDef::getVhdlSpecifiers().

Referenced by writeTagFile().

isConstraint()

bool VhdlDocGen::isConstraint ( const MemberDef * mdef )

static

Definition at line 2433 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::UCF_CONST; }

References MemberDef::getVhdlSpecifiers(), and UCF_CONST.

Referenced by writeVHDLTypeDocumentation().

isEntity()

bool VhdlDocGen::isEntity ( const MemberDef * mdef )

static

Definition at line 2449 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::ENTITY; }

References ENTITY, and MemberDef::getVhdlSpecifiers().

Referenced by writeTagFile().

isFile()

bool VhdlDocGen::isFile ( const MemberDef * mdef )

static

Definition at line 2479 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::VFILE; }

References MemberDef::getVhdlSpecifiers(), and VFILE.

Referenced by writeTagFile().

isGeneric()

bool VhdlDocGen::isGeneric ( const MemberDef * mdef )

static

Definition at line 2441 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::GENERIC; }

References GENERIC, and MemberDef::getVhdlSpecifiers().

Referenced by writeTagFile(), and writeVHDLTypeDocumentation().

isGroup()

bool VhdlDocGen::isGroup ( const MemberDef * mdef )

static

Definition at line 2481 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::GROUP; }

References MemberDef::getVhdlSpecifiers(), and GROUP.

Referenced by writeTagFile().

isLibrary()

bool VhdlDocGen::isLibrary ( const MemberDef * mdef )

static

Definition at line 2439 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::LIBRARY; }

References MemberDef::getVhdlSpecifiers(), and LIBRARY.

Referenced by writeTagFile(), and writeVHDLTypeDocumentation().

isMisc()

bool VhdlDocGen::isMisc ( const MemberDef * mdef )

static

Definition at line 2485 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::MISCELLANEOUS; }

References MemberDef::getVhdlSpecifiers(), and MISCELLANEOUS.

Referenced by MemberDefImpl::writeDocumentation().

isNumber()

bool VhdlDocGen::isNumber ( const std::string & s )

static

returns true if this string is a number

Definition at line 836 of file vhdldocgen.cpp.

{
  static const reg::Ex regg(R"([0-9][0-9eEfFbBcCdDaA_.#+?xXzZ-]*)");
  return reg::match(s,regg);
}// isNumber

References reg::match().

Referenced by checkVhdlString(), writeFormatString(), writeRecordProto(), and writeWord().

isPackage()

bool VhdlDocGen::isPackage ( const MemberDef * mdef )

static

Definition at line 2447 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::USE; }

References MemberDef::getVhdlSpecifiers(), and USE.

Referenced by findAllPackages(), writeTagFile(), and writeVHDLTypeDocumentation().

isPackageBody()

bool VhdlDocGen::isPackageBody ( const MemberDef * mdef )

static

Definition at line 2475 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::PACKAGE_BODY; }

References MemberDef::getVhdlSpecifiers(), and PACKAGE_BODY.

isPort()

bool VhdlDocGen::isPort ( const MemberDef * mdef )

static

Definition at line 2443 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::PORT; }

References MemberDef::getVhdlSpecifiers(), and PORT.

Referenced by writeTagFile(), and writeVHDLTypeDocumentation().

isProcedure()

bool VhdlDocGen::isProcedure ( const MemberDef * mdef )

static

Definition at line 2467 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::PROCEDURE; }

References MemberDef::getVhdlSpecifiers(), and PROCEDURE.

Referenced by findFunction(), writeFuncProcDocu(), writeTagFile(), and writeVHDLTypeDocumentation().

isProcess()

bool VhdlDocGen::isProcess ( const MemberDef * mdef )

static

Definition at line 2459 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::PROCESS; }

References MemberDef::getVhdlSpecifiers(), and PROCESS.

Referenced by writeFuncProcDocu(), writeTagFile(), and writeVHDLTypeDocumentation().

isRecord()

bool VhdlDocGen::isRecord ( const MemberDef * mdef )

static

Definition at line 2469 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::RECORD; }

References MemberDef::getVhdlSpecifiers(), and RECORD.

Referenced by writeTagFile().

isSignal()

bool VhdlDocGen::isSignal ( const MemberDef * mdef )

static

Definition at line 2461 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::SIGNAL; }

References MemberDef::getVhdlSpecifiers(), and SIGNAL.

isSignals()

bool VhdlDocGen::isSignals ( const MemberDef * mdef )

static

Definition at line 2465 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::SIGNAL; }

References MemberDef::getVhdlSpecifiers(), and SIGNAL.

Referenced by writeTagFile().

isSubClass()

bool VhdlDocGen::isSubClass ( ClassDef * cd, ClassDef * scd, bool followInstances, int level )

static

Definition at line 2313 of file vhdldocgen.cpp.

{
  bool found=false;
  //printf("isBaseClass(cd=%s) looking for %s\n",qPrint(name()),qPrint(bcd->name()));
  if (level>255)
  {
    err("Possible recursive class relation while inside {} and looking for {}\n",cd->name(),scd->name());
    abort();
  }
 
  for (const auto &bcd :cd->subClasses())
  {
    const ClassDef *ccd=bcd.classDef;
    if (!followInstances && ccd->templateMaster()) ccd=ccd->templateMaster();
    //printf("isSubClass() subclass %s\n",qPrint(ccd->name()));
    if (ccd==scd)
    {
      found=true;
    }
    else
    {
      if (level <256)
      {
        level = ccd->isBaseClass(scd,followInstances);
        if (level>0)
        {
          found=true;
        }
      }
    }
  }
  return found;
}

References err, ClassDef::isBaseClass(), Definition::name(), ClassDef::subClasses(), and ClassDef::templateMaster().

Referenced by addInstance().

isSubType()

bool VhdlDocGen::isSubType ( const MemberDef * mdef )

static

Definition at line 2455 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::SUBTYPE; }

References MemberDef::getVhdlSpecifiers(), and SUBTYPE.

Referenced by writeTagFile().

isUnit()

bool VhdlDocGen::isUnit ( const MemberDef * mdef )

static

Definition at line 2473 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::UNITS; }

References MemberDef::getVhdlSpecifiers(), and UNITS.

isVariable()

bool VhdlDocGen::isVariable ( const MemberDef * mdef )

static

Definition at line 2477 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::SHAREDVARIABLE; }

References MemberDef::getVhdlSpecifiers(), and SHAREDVARIABLE.

Referenced by writeTagFile().

isVhdlClass()

bool VhdlDocGen::isVhdlClass ( const Entry * cu )

inlinestatic

Definition at line 212 of file vhdldocgen.h.

    {
      return cu->vhdlSpec==VhdlSpecifier::ENTITY       ||
             cu->vhdlSpec==VhdlSpecifier::PACKAGE      ||
             cu->vhdlSpec==VhdlSpecifier::ARCHITECTURE ||
             cu->vhdlSpec==VhdlSpecifier::PACKAGE_BODY;
    }

References ARCHITECTURE, ENTITY, PACKAGE, PACKAGE_BODY, and Entry::vhdlSpec.

Referenced by VHDLOutlineParser::mapLibPackage().

isVhdlFunction()

bool VhdlDocGen::isVhdlFunction ( const MemberDef * mdef )

static

Definition at line 2457 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::FUNCTION; }

References FUNCTION, and MemberDef::getVhdlSpecifiers().

Referenced by findFunction(), writeFuncProcDocu(), writeTagFile(), and writeVHDLTypeDocumentation().

isVType()

bool VhdlDocGen::isVType ( const MemberDef * mdef )

static

Definition at line 2453 of file vhdldocgen.cpp.

{ return mdef->getVhdlSpecifiers()==VhdlSpecifier::TYPE; }

References MemberDef::getVhdlSpecifiers(), and TYPE.

Referenced by writeTagFile().

parseForBinding()

DString VhdlDocGen::parseForBinding ( DString & entity, DString & arch )

static

Definition at line 2087 of file vhdldocgen.cpp.

{
  static const reg::Ex exp(R"([()\s])");
 
  auto ql = split(entity.str(),exp);
 
  if (findIndex(ql,"open")!=-1)
  {
    return "open";
  }
 
  if (ql.size()<2)
  {
    return "";
  }
 
  std::string label=ql[0];
  entity = ql[1];
  if (size_t index=entity.rfind('.'); index!=DString::npos)
  {
    entity.remove(0,index+1);
  }
 
  if (ql.size()==3)
  {
    arch=ql[2];
  }
  return label;
}

References findIndex(), DString::npos, DString::remove(), DString::rfind(), split(), and DString::str().

Referenced by computeVhdlComponentRelations(), and writeRecordProto().

parseForConfig()

DString VhdlDocGen::parseForConfig ( DString & entity, DString & arch )

static

Definition at line 2056 of file vhdldocgen.cpp.

{
  if (!entity.contains(":")) return "";
 
  static const reg::Ex exp(R"([:()\s])");
  auto ql=split(entity.str(),exp);
  if (ql.size()<2)
  {
    return "";
  }
  DString label(ql[0]);
  entity = ql[1];
  if (size_t index = entity.rfind('.'); index!=DString::npos)
  {
    entity.remove(0,index+1);
  }
 
  if (ql.size()==3)
  {
    arch = ql[2];
    ql=split(arch.str(),exp);
    if (ql.size()>1) // expression
    {
      arch="";
    }
  }
  return label; // label
}

References DString::contains(), DString::npos, DString::remove(), DString::rfind(), split(), and DString::str().

Referenced by writeRecordProto().

parseFuncProto()

void VhdlDocGen::parseFuncProto ( const DString & text, DString & name, DString & ret, bool doc = false )

static

parses a function proto

Parameters

text	function string
name	points to the function name
ret	Stores the return type
doc	???

Definition at line 631 of file vhdldocgen.cpp.

{
  DString s1(text);
  DString temp;
 
  size_t index=s1.find('(');
  if (index==DString::npos) index=0;
  size_t end=s1.rfind(')');
 
  if (end!=DString::npos && end>index)
  {
    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
  {
    s1=s1.stripWhiteSpace();
    size_t i=s1.find('(');
    size_t s=s1.find(' ');
    if (s==DString::npos) s=s1.find('\t');
    if (i==DString::npos || (s!=DString::npos && (i==DString::npos || i<s)))
      s1=VhdlDocGen::getIndexWord(s1,1);
    else // s<i, s=start of name, i=end of name
      s1=s1.mid(s,(i-s));
 
    name=s1.stripWhiteSpace();
  }
  index=s1.rfind_insensitive("return");
  if (index!=DString::npos)
  {
    ret=s1.mid(index+6,s1.length());
    ret=ret.stripWhiteSpace();
    VhdlDocGen::deleteCharRev(ret,';');
  }
}

References deleteCharRev(), end(), DString::find(), getIndexWord(), DString::left(), DString::length(), DString::mid(), DString::npos, DString::rfind(), DString::rfind_insensitive(), and DString::stripWhiteSpace().

Referenced by writeFuncProto().

parseUCF()

void VhdlDocGen::parseUCF ( const DString & input, Entry * entity, const DString & f, bool vendor )

static

Definition at line 1914 of file vhdldocgen.cpp.

{
  DString ucFile(input);
  int lineNo=0;
  DString comment("#!");
  DString brief;
 
  while (!ucFile.empty())
  {
    size_t i=ucFile.find('\n');
    if (i==DString::npos) break;
    lineNo++;
    DString temp=ucFile.left(i);
    temp=temp.stripWhiteSpace();
    bool bb=temp.stripPrefix("//");
 
    if (!temp.empty())
    {
      if (temp.stripPrefix(comment) )
      {
        brief+=temp;
        brief.append("\\n");
      }
      else if (!temp.stripPrefix("#") && !bb)
      {
        if (altera)
        {
          size_t in=temp.find("-name");
          if (in!=DString::npos && in>0)
          {
            temp=temp.remove(0,in+5);
          }
 
          temp.stripPrefix("set_location_assignment");
 
          initUCF(entity,DString(),temp,lineNo,fileName,brief);
        }
        else
        {
          static const reg::Ex ee(R"([\s=])");
          int in=findIndex(temp.str(),ee);
          if (in<0) in=0;
          DString ff=temp.left(in);
          temp.stripPrefix(ff);
          ff.append("#");
          if (!temp.empty())
          {
            initUCF(entity,ff,temp,lineNo,fileName,brief);
          }
        }
      }
    }//temp
 
    ucFile=ucFile.remove(0,i+1);
  }// while
}

References DString::append(), DString::DString(), DString::empty(), DString::find(), findIndex(), initUCF(), DString::left(), DString::npos, DString::remove(), DString::str(), DString::stripPrefix(), and DString::stripWhiteSpace().

Referenced by VHDLOutlineParser::parseInput(), and writeRecordProto().

prepareComment()

void VhdlDocGen::prepareComment ( DString & qcs )

static

strips the "--!" prefixes of vhdl comments

Definition at line 591 of file vhdldocgen.cpp.

{
  qcs=qcs.stripWhiteSpace();
  if (qcs.empty()) return;
 
  const char* sc="--!";
  if (qcs.startsWith(sc)) qcs = qcs.mid(dstrlen(sc));
  static const reg::Ex re(R"(\n[ \t]*--!)");
  std::string s = qcs.str();
  reg::Iterator iter(s,re);
  reg::Iterator end;
  std::string result;
  size_t p=0;
  size_t sl=s.length();
  for ( ; iter!=end ; ++iter)
  {
    const auto &match = *iter;
    size_t i = match.position();
    result+="\n";
    result+=s.substr(p,i-p);
    p = match.position()+match.length();
  }
  if (p<sl)
  {
    result+="\n";
    result+=s.substr(p);
  }
 
  qcs = result;
  qcs=qcs.stripWhiteSpace();
}

References dstrlen(), DString::empty(), end(), DString::mid(), DString::startsWith(), DString::str(), and DString::stripWhiteSpace().

Referenced by VHDLOutlineParser::checkInlineCode(), VHDLOutlineParser::checkMultiComment(), and VHDLOutlineParser::handleCommentBlock().

resetCodeVhdlParserState()

void VhdlDocGen::resetCodeVhdlParserState ( )

static

Definition at line 2425 of file vhdldocgen.cpp.

{
  std::lock_guard lock(g_vhdlMutex);
  g_varMap.clear();
  g_classList.clear();
  g_packages.clear();
}

References g_classList, g_packages, g_varMap, and g_vhdlMutex.

setFlowMember()

void VhdlDocGen::setFlowMember ( const MemberDef * flowMember )

static

Definition at line 75 of file vhdldocgen.cpp.

{
  flowMember=mem;
}

References flowMember.

Referenced by createFlowChart(), and writeRecordProto().

writeClassType()

bool VhdlDocGen::writeClassType ( const ClassDef * cd, OutputList & ol, DString & cname )

static

Definition at line 1809 of file vhdldocgen.cpp.

{
  DString qcs = theTranslator->trVhdlType(getSpecifierTypeFromClass(cd),true);
  cname=VhdlDocGen::getClassName(cd);
  ol.startBold();
  ol.writeString(qcs);
  ol.writeString(" ");
  ol.endBold();
  //ol.insertMemberAlign();
  return false;
}// writeClassLink

References OutputList::endBold(), getClassName(), getSpecifierTypeFromClass(), OutputList::startBold(), theTranslator, Translator::trVhdlType(), and OutputList::writeString().

Referenced by writeRecordProto().

writeFormatString()

void VhdlDocGen::writeFormatString ( const DString & s, OutputList & ol, const MemberDef * mdef )

static

writes a colored and formatted string

Definition at line 767 of file vhdldocgen.cpp.

{
  static const reg::Ex reg(R"([\‍[\‍]./<>:\s,;'+*|&=()\"-])");
  DString qcs = s;
  qcs+=DString(" ");// parsing the last sign
  DString find=qcs;
  DString temp=qcs;
  char buf[2];
  buf[1]='\0';
 
  int j = findIndex(temp.str(),reg);
 
  ol.startBold();
  if (j>=0)
  {
    while (j>=0)
    {
      find=find.left(j);
      buf[0]=temp[j];
      const char *ss=VhdlDocGen::findKeyWord(find);
      bool k=isNumber(find.str()); // is this a number
      if (k)
      {
        ol.docify(" ");
        startFonts(find,"vhdldigit",ol);
        ol.docify(" ");
      }
      else if (j != 0 && ss)
      {
        startFonts(find,ss,ol);
      }
      else
      {
        if (j>0)
        {
          VhdlDocGen::writeStringLink(mdef,find,ol);
        }
      }
      startFonts(&buf[0],"vhdlchar",ol);
 
      DString st=temp.remove(0,j+1);
      find=st;
      if (!find.empty() && find.at(0)=='"')
      {
        size_t ii=find.find('"',2);
        if (ii!=DString::npos && ii>1)
        {
          DString com=find.left(ii+1);
          startFonts(com,"keyword",ol);
          temp=find.remove(0,ii+1);
        }
      }
      else
      {
        temp=st;
      }
      j = findIndex(temp.str(),reg);
    }//while
  }//if
  else
  {
    startFonts(find,"vhdlchar",ol);
  }
  ol.endBold();
}// writeFormatString

References DString::at(), OutputList::docify(), DString::DString(), DString::empty(), OutputList::endBold(), DString::find(), findIndex(), findKeyWord(), isNumber(), DString::left(), DString::npos, DString::remove(), OutputList::startBold(), startFonts(), DString::str(), and writeStringLink().

Referenced by formatString(), writeFuncProcDocu(), and writeProcessProto().

writeFuncProcDocu()

bool VhdlDocGen::writeFuncProcDocu ( const MemberDef * md, OutputList & ol, const ArgumentList & al, bool type = false )

static

writes a function|procedure documentation to the output

Definition at line 1064 of file vhdldocgen.cpp.

{
  //bool sem=false;
  ol.enableAll();
 
  size_t index=al.size();
  if (index==0)
  {
    ol.docify(" ( ) ");
    return false;
  }
  ol.endMemberDocName();
  ol.startParameterList(true);
  //ol.startParameterName(false);
  bool first=true;
  for (const Argument &arg : al)
  {
    ol.startParameterType(first,"");
    //   if (first) ol.writeChar('(');
    DString attl=arg.defval;
 
    //bool bGen=attl.stripPrefix("generic");
    //if (bGen)
    //  VhdlDocGen::writeFormatString(DString("generic "),ol,md);
 
 
    if (VhdlDocGen::isProcedure(md) || VhdlDocGen::isVhdlFunction(md) )
    {
      startFonts(arg.defval,"keywordtype",ol);
      ol.docify(" ");
    }
    ol.endParameterType();
 
    ol.startParameterName(true);
    VhdlDocGen::writeFormatString(arg.name,ol,md);
 
    if (VhdlDocGen::isProcedure(md))
    {
      startFonts(arg.attrib,"stringliteral",ol);
    }
    else if (VhdlDocGen::isVhdlFunction(md))
    {
      startFonts(DString("in"),"stringliteral",ol);
    }
 
    ol.docify(" ");
    ol.disable(OutputType::Man);
    ol.startEmphasis();
    ol.enable(OutputType::Man);
    if (!VhdlDocGen::isProcess(md))
    {
     // startFonts(arg.type,"vhdlkeyword",ol);
                VhdlDocGen::writeFormatString(arg.type,ol,md);
    }
    ol.disable(OutputType::Man);
    ol.endEmphasis();
    ol.enable(OutputType::Man);
 
    if (--index)
    {
      ol.docify(" , ");
    }
    else
    {
      //    ol.docify(" ) ");
      ol.endParameterName();
      ol.startParameterExtra();
      ol.endParameterExtra(true,false,true);
      break;
    }
    ol.endParameterName();
    ol.startParameterExtra();
    ol.endParameterExtra(false,false,false);
 
    //sem=true;
    first=false;
  }
  //ol.endParameterList();
  return true;
 
} // writeDocFunProc

References OutputList::disable(), OutputList::docify(), DString::DString(), OutputList::enable(), OutputList::enableAll(), OutputList::endEmphasis(), OutputList::endMemberDocName(), OutputList::endParameterExtra(), OutputList::endParameterName(), OutputList::endParameterType(), isProcedure(), isProcess(), isVhdlFunction(), Man, ArgumentList::size(), OutputList::startEmphasis(), startFonts(), OutputList::startParameterExtra(), OutputList::startParameterList(), OutputList::startParameterName(), OutputList::startParameterType(), and writeFormatString().

Referenced by writeVHDLTypeDocumentation().

writeFunctionProto()

void VhdlDocGen::writeFunctionProto ( OutputList & ol, const ArgumentList & al, const MemberDef * mdef )

static

writes a function prototype to the output

Definition at line 960 of file vhdldocgen.cpp.

{
  if (!al.hasParameters()) return;
  bool sem=false;
  size_t len=al.size();
  ol.startBold();
  ol.docify(" ( ");
  ol.endBold();
  if (len>2)
  {
    ol.lineBreak();
  }
  for (const Argument &arg : al)
  {
    ol.startBold();
    DString att=arg.defval;
     bool bGen=att.stripPrefix("generic");
 
    if (sem && len < 3)
    {
      ol.docify(" , ");
    }
 
    if (bGen)
    {
      VhdlDocGen::formatString(DString("generic "),ol,mdef);
    }
    if (!att.empty())
    {
      const char *str=VhdlDocGen::findKeyWord(att);
      att+=" ";
      if (str)
        VhdlDocGen::formatString(att,ol,mdef);
      else
        startFonts(att,"vhdlchar",ol);
    }
 
    DString nn=arg.name;
    nn+=": ";
    DString ss=arg.type.stripWhiteSpace(); //.lower();
    DString w=ss.stripWhiteSpace();//.upper();
    startFonts(nn,"vhdlchar",ol);
    startFonts("in ","stringliteral",ol);
    const char *str=VhdlDocGen::findKeyWord(ss);
    if (str)
      VhdlDocGen::formatString(w,ol,mdef);
    else
      startFonts(w,"vhdlchar",ol);
 
    if (!arg.attrib.empty())
      startFonts(arg.attrib,"vhdlchar",ol);
 
    sem=true;
    ol.endBold();
    if (len > 2)
    {
      ol.lineBreak();
    }
  }
  ol.startBold();
  ol.docify(" )");
  DString exp=mdef->excpString();
  if (!exp.empty())
  {
    ol.insertMemberAlign();
    ol.startBold();
    ol.docify("[ ");
    ol.docify(exp);
    ol.docify(" ]");
    ol.endBold();
  }
  ol.endBold();
}

References OutputList::docify(), DString::DString(), DString::empty(), OutputList::endBold(), MemberDef::excpString(), findKeyWord(), formatString(), ArgumentList::hasParameters(), OutputList::insertMemberAlign(), OutputList::lineBreak(), ArgumentList::size(), OutputList::startBold(), startFonts(), DString::stripPrefix(), and DString::stripWhiteSpace().

Referenced by writeVHDLDeclaration().

writeInlineClassLink()

void VhdlDocGen::writeInlineClassLink ( const ClassDef * cd, OutputList & ol )

static

writes an inline link form entity|package to architecture|package body and vice verca

Definition at line 463 of file vhdldocgen.cpp.

{
  std::vector<DString> ql;
  DString nn=cd->className();
  VhdlClasses ii=convert(cd->protection());
 
  DString type = theTranslator_vhdlType(getSpecifierTypeFromClass(cd),true);
 
  //type=type.lower();
  type+=" >> ";
  ol.disable(OutputType::RTF);
  ol.disable(OutputType::Man);
 
  if (ii==VhdlDocGen::PACKBODYCLASS)
  {
    nn.stripPrefix("_");
    cd=getClass(nn);
  }
  else  if (ii==VhdlDocGen::PACKAGECLASS)
  {
    nn.prepend("_");
    cd=getClass(nn);
  }
  else if (ii==VhdlDocGen::ARCHITECTURECLASS)
  {
    StringVector qlist=split(nn.str(),"-");
    if (qlist.size()>1)
    {
      nn=qlist[1];
      cd=VhdlDocGen::getClass(nn);
    }
  }
 
  DString opp;
  if (ii==VhdlDocGen::ENTITYCLASS)
  {
    VhdlDocGen::findAllArchitectures(ql,cd);
    for (const auto &s : ql)
    {
      StringVector qlist=split(s.str(),"-");
      if (qlist.size()>2)
      {
        DString s1(qlist[0]);
        DString s2(qlist[1]);
        s1.stripPrefix("_");
        if (ql.size()==1) s1.clear();
        ClassDef *cc = getClass(s);
        if (cc)
        {
          VhdlDocGen::writeVhdlLink(cc,ol,type,s2,s1);
        }
      }
    }
  }
  else
  {
    VhdlDocGen::writeVhdlLink(cd,ol,type,nn,opp);
  }
 
  ol.enable(OutputType::Man);
  ol.enable(OutputType::RTF);
 
}// write

References ARCHITECTURECLASS, ClassDef::className(), DString::clear(), convert(), OutputList::disable(), OutputList::enable(), ENTITYCLASS, findAllArchitectures(), getClass(), getSpecifierTypeFromClass(), Man, PACKAGECLASS, PACKBODYCLASS, DString::prepend(), ClassDef::protection(), RTF, split(), DString::str(), DString::stripPrefix(), theTranslator_vhdlType, and writeVhdlLink().

Referenced by ClassDefImpl::writeMemberDeclarations().

writePlainVHDLDeclarations()

void VhdlDocGen::writePlainVHDLDeclarations ( const MemberList * ml, OutputList & ol, const ClassDef * cd, const NamespaceDef * nd, const FileDef * fd, const GroupDef * gd, const ModuleDef * mod, VhdlSpecifier specifier )

static

Definition at line 1692 of file vhdldocgen.cpp.

{
 
  StringSet pack;
 
  bool first=true;
  for (const auto &imd : *mlist)
  {
    MemberDefMutable *md = toMemberDefMutable(imd);
    if (md)
    {
      VhdlSpecifier mems=md->getVhdlSpecifiers();
      if (md->isBriefSectionVisible() && (mems==specifier) && (mems!=VhdlSpecifier::LIBRARY) )
      {
        if (first) { ol.startMemberList();first=false; }
        VhdlDocGen::writeVHDLDeclaration(md,ol,cd,nd,fd,gd,mod,false);
      } //if
      else if (md->isBriefSectionVisible() && (mems==specifier))
      {
        if (pack.find(md->name().str())==pack.end())
        {
          if (first) ol.startMemberList(),first=false;
          VhdlDocGen::writeVHDLDeclaration(md,ol,cd,nd,fd,gd,mod,false);
          pack.insert(md->name().str());
        }
      } //if
    } //if
  } //for
  if (!first) ol.endMemberList();
}//plainDeclaration

References OutputList::endMemberList(), MemberDef::getVhdlSpecifiers(), MemberDef::isBriefSectionVisible(), LIBRARY, Definition::name(), OutputList::startMemberList(), DString::str(), toMemberDefMutable(), and writeVHDLDeclaration().

Referenced by writeRecordProto(), and writeVHDLDeclarations().

writeProcedureProto()

void VhdlDocGen::writeProcedureProto ( OutputList & ol, const ArgumentList & al, const MemberDef * mdef )

static

writes a procedure prototype to the output

Definition at line 905 of file vhdldocgen.cpp.

{
  bool sem=false;
  size_t len=al.size();
  ol.docify("( ");
  if (len > 2)
  {
    ol.lineBreak();
  }
  for (const Argument &arg : al)
  {
    ol.startBold();
    if (sem && len <3)
      ol.writeChar(',');
 
    DString nn=arg.name;
    nn+=": ";
 
    DString defval = arg.defval;
    const char *str=VhdlDocGen::findKeyWord(defval);
    defval+=" ";
    if (str)
    {
      startFonts(defval,str,ol);
    }
    else
    {
      startFonts(defval,"vhdlchar",ol); // write type (variable,constant etc.)
    }
 
    startFonts(nn,"vhdlchar",ol); // write name
    if (dstricmp(arg.attrib,arg.type) != 0)
    {
      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(" )");
 
 
}

References OutputList::docify(), dstricmp(), OutputList::endBold(), findKeyWord(), formatString(), OutputList::lineBreak(), ArgumentList::size(), OutputList::startBold(), startFonts(), and OutputList::writeChar().

Referenced by writeVHDLDeclaration().

writeProcessProto()

void VhdlDocGen::writeProcessProto ( OutputList & ol, const ArgumentList & al, const MemberDef * mdef )

static

writes a process prototype to the output

Definition at line 1038 of file vhdldocgen.cpp.

{
  if (!al.hasParameters()) return;
  bool sem=false;
  ol.startBold();
  ol.docify(" ( ");
  for (const Argument &arg : al)
  {
    if (sem)
    {
      ol.docify(" , ");
    }
    DString nn=arg.name;
    // startFonts(nn,"vhdlchar",ol);
    VhdlDocGen::writeFormatString(nn,ol,mdef);
    sem=true;
  }
  ol.docify(" )");
  ol.endBold();
}

References OutputList::docify(), OutputList::endBold(), ArgumentList::hasParameters(), OutputList::startBold(), and writeFormatString().

Referenced by writeVHDLDeclaration().

writeRecordProto()

void VhdlDocGen::writeRecordProto ( const MemberDef * mdef, OutputList & ol, const ArgumentList & al )

static

References addBaseClass(), convertArgumentListToString(), correctMemberProperties(), createFlowChart(), findArchitecture(), findVhdlClass(), getClassName(), getFlowMember(), getProcessNumber(), getProtectionName(), getRecordNumber(), isNumber(), parseForBinding(), parseForConfig(), parseUCF(), setFlowMember(), writeClassType(), writePlainVHDLDeclarations(), writeSource(), writeVHDLDeclaration(), writeVHDLDeclarations(), writeVhdlDeclarations(), and writeVHDLTypeDocumentation().

writeRecordUnit()

void VhdlDocGen::writeRecordUnit ( DString & largs, DString & ltype, OutputList & ol, MemberDefMutable * mdef )

staticprivate

Definition at line 2258 of file vhdldocgen.cpp.

{
  if (size_t i=mdef->name().find('~'); i!=DString::npos && i>0)
  {
    //sets the real record member name
    mdef->setName(mdef->name().left(i));
  }
 
  writeLink(mdef,ol);
  ol.startBold();
  ol.insertMemberAlign();
  if (!ltype.empty())
  {
    VhdlDocGen::formatString(ltype,ol,mdef);
  }
  ol.endBold();
}

References DString::empty(), OutputList::endBold(), DString::find(), formatString(), OutputList::insertMemberAlign(), DString::left(), Definition::name(), DString::npos, DefinitionMutable::setName(), OutputList::startBold(), and writeLink().

Referenced by compareArgList(), and writeVHDLDeclaration().

writeRecUnitDocu()

void VhdlDocGen::writeRecUnitDocu ( const MemberDef * md, OutputList & ol, DString largs )

staticprivate

Definition at line 2277 of file vhdldocgen.cpp.

{
 
  StringVector ql=split(largs.str(),"#");
  size_t len=ql.size();
  ol.startParameterList(true);
  bool first=true;
 
  for(size_t i=0;i<len;i++)
  {
    DString n = ql[i];
    ol.startParameterType(first,"");
    ol.endParameterType();
    ol.startParameterName(true);
    VhdlDocGen::formatString(n,ol,md);
    ol.endParameterName();
    ol.startParameterExtra();
    if ((len-i)>1)
    {
      ol.endParameterExtra(false,false,false);
    }
    else
    {
      ol.endParameterExtra(true,false,true);
    }
 
    first=false;
  }
 
}//#

References OutputList::endParameterExtra(), OutputList::endParameterName(), OutputList::endParameterType(), formatString(), split(), OutputList::startParameterExtra(), OutputList::startParameterList(), OutputList::startParameterName(), OutputList::startParameterType(), and DString::str().

Referenced by compareArgList(), and writeVHDLTypeDocumentation().

writeSource()

void VhdlDocGen::writeSource ( const MemberDef * mdef, OutputList & ol, const DString & cname )

static

Definition at line 1849 of file vhdldocgen.cpp.

{
  auto intf = Doxygen::parserManager->getCodeParser(".vhd");
 // pIntf->resetCodeParserState();
 
  DString codeFragment=mdef->documentation();
 
  if (cname.empty())
  {
    writeLink(mdef,ol);
    size_t fi=0;
    int j=0;
    do { fi=codeFragment.find('\n',++fi); } while (fi!=DString::npos && j++ <3);
 
    // show only the first four lines
    if (j==4)
    {
      codeFragment=codeFragment.left(fi);
      codeFragment.append("\n    ....    ");
    }
  }
 
  codeFragment.prepend("\n");
  ol.pushGeneratorState();
  auto &codeOL = ol.codeGenerators();
  codeOL.startCodeFragment("DoxyCode");
  intf->parseCode(codeOL,           // codeOutIntf
                  DString(),       // scope
                  codeFragment,     // input
                  SrcLangExt::VHDL,  // lang
                  Config_getBool(STRIP_CODE_COMMENTS),
                  CodeParserOptions()
                  .setFileDef(mdef->getFileDef())
                  .setStartLine(mdef->getStartBodyLine())
                  .setEndLine(mdef->getEndBodyLine())
                  .setInlineFragment(true)
                  .setMemberDef(mdef)
                 );
 
  codeOL.endCodeFragment("DoxyCode");
  ol.popGeneratorState();
 
  if (cname.empty()) return;
 
  MemberDefMutable *mdm = toMemberDefMutable(const_cast<MemberDef*>(mdef));
  if (mdm)
  {
    mdm->writeSourceDef(ol);
    if (mdef->hasReferencesRelation()) mdm->writeSourceRefs(ol,cname);
    if (mdef->hasReferencedByRelation()) mdm->writeSourceReffedBy(ol,cname);
  }
}

References DString::append(), OutputList::codeGenerators(), Config_getBool, Definition::documentation(), DString::DString(), DString::empty(), DString::find(), ParserManager::getCodeParser(), Definition::getEndBodyLine(), MemberDef::getFileDef(), Definition::getStartBodyLine(), MemberDef::hasReferencedByRelation(), MemberDef::hasReferencesRelation(), DString::left(), DString::npos, Doxygen::parserManager, OutputList::popGeneratorState(), DString::prepend(), OutputList::pushGeneratorState(), CodeParserOptions::setEndLine(), CodeParserOptions::setInlineFragment(), CodeParserOptions::setMemberDef(), CodeParserOptions::setStartLine(), OutputCodeList::startCodeFragment(), toMemberDefMutable(), writeLink(), DefinitionMutable::writeSourceDef(), DefinitionMutable::writeSourceReffedBy(), and DefinitionMutable::writeSourceRefs().

Referenced by MemberDefImpl::writeDocumentation(), writeRecordProto(), and writeVHDLDeclaration().

writeStringLink()

void VhdlDocGen::writeStringLink ( const MemberDef * mdef, DString mem, OutputList & ol )

staticprivate

writes a link if the string is linkable else a formatted string

Definition at line 1825 of file vhdldocgen.cpp.

{
  if (mdef)
  {
    const ClassDef *cd=mdef->getClassDef();
    if (cd)
    {
      DString n=cd->name();
      const MemberDef* memdef=VhdlDocGen::findMember(n,mem);
      if (memdef && memdef->isLinkable())
      {
        ol.startBold();
        writeLink(memdef,ol);
        ol.endBold();
        ol.docify(" ");
        return;
      }
    }
  }
  startFonts(mem,"vhdlchar",ol);
}// found component

References OutputList::docify(), OutputList::endBold(), findMember(), MemberDef::getClassDef(), Definition::isLinkable(), Definition::name(), OutputList::startBold(), startFonts(), and writeLink().

Referenced by compareArgList(), and writeFormatString().

writeTagFile()

void VhdlDocGen::writeTagFile ( MemberDefMutable * mdef, TextStream & tagFile )

static

Definition at line 1343 of file vhdldocgen.cpp.

{
  tagFile << "    <member kind=\"";
  if (VhdlDocGen::isGeneric(mdef))      tagFile << "generic";
  if (VhdlDocGen::isPort(mdef))         tagFile << "port";
  if (VhdlDocGen::isEntity(mdef))       tagFile << "entity";
  if (VhdlDocGen::isComponent(mdef))    tagFile << "component";
  if (VhdlDocGen::isVType(mdef))        tagFile << "type";
  if (VhdlDocGen::isConstant(mdef))     tagFile << "constant";
  if (VhdlDocGen::isSubType(mdef))      tagFile << "subtype";
  if (VhdlDocGen::isVhdlFunction(mdef)) tagFile << "function";
  if (VhdlDocGen::isProcedure(mdef))    tagFile << "procedure";
  if (VhdlDocGen::isProcess(mdef))      tagFile << "process";
  if (VhdlDocGen::isSignals(mdef))      tagFile << "signal";
  if (VhdlDocGen::isAttribute(mdef))    tagFile << "attribute";
  if (VhdlDocGen::isRecord(mdef))       tagFile << "record";
  if (VhdlDocGen::isLibrary(mdef))      tagFile << "library";
  if (VhdlDocGen::isPackage(mdef))      tagFile << "package";
  if (VhdlDocGen::isVariable(mdef))     tagFile << "shared variable";
  if (VhdlDocGen::isFile(mdef))         tagFile << "file";
  if (VhdlDocGen::isGroup(mdef))        tagFile << "group";
  if (VhdlDocGen::isCompInst(mdef))     tagFile << "instantiation";
  if (VhdlDocGen::isAlias(mdef))        tagFile << "alias";
  if (VhdlDocGen::isCompInst(mdef))     tagFile << "configuration";
 
  DString fn = mdef->getOutputFileBase();
  addHtmlExtensionIfMissing(fn);
  tagFile << "\">\n";
  tagFile << "      <type>" << convertToXML(mdef->typeString()) << "</type>\n";
  tagFile << "      <name>" << convertToXML(mdef->name()) << "</name>\n";
  tagFile << "      <anchorfile>" << convertToXML(fn) << "</anchorfile>\n";
  tagFile << "      <anchor>" << convertToXML(mdef->anchor()) << "</anchor>\n";
 
  if (VhdlDocGen::isVhdlFunction(mdef))
    tagFile << "      <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList(),true)) << "</arglist>\n";
  else if (VhdlDocGen::isProcedure(mdef))
    tagFile << "      <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList(),false)) << "</arglist>\n";
  else
    tagFile << "      <arglist>" << convertToXML(mdef->argsString()) << "</arglist>\n";
 
  mdef->writeDocAnchorsToTagFile(tagFile);
  tagFile << "    </member>\n";
}

References addHtmlExtensionIfMissing(), Definition::anchor(), MemberDef::argsString(), MemberDef::argumentList(), convertArgumentListToString(), convertToXML(), Definition::getOutputFileBase(), isAlias(), isAttribute(), isCompInst(), isComponent(), isConstant(), isEntity(), isFile(), isGeneric(), isGroup(), isLibrary(), isPackage(), isPort(), isProcedure(), isProcess(), isRecord(), isSignals(), isSubType(), isVariable(), isVhdlFunction(), isVType(), Definition::name(), MemberDef::typeString(), and DefinitionMutable::writeDocAnchorsToTagFile().

Referenced by MemberList::writeTagFile().

writeVHDLDeclaration()

void VhdlDocGen::writeVHDLDeclaration ( MemberDefMutable * mdef, OutputList & ol, const ClassDef * cd, const NamespaceDef * nd, const FileDef * fd, const GroupDef * gd, const ModuleDef * mod, bool inGroup )

static

printf("startMemberItem for %s\n",qPrint(name()));

Definition at line 1389 of file vhdldocgen.cpp.

{
  const Definition *d=nullptr;
 
  ASSERT(cd!=nullptr || nd!=nullptr || fd!=nullptr || gd!=nullptr || mod!=nullptr ||
      mdef->getVhdlSpecifiers()==VhdlSpecifier::LIBRARY ||
      mdef->getVhdlSpecifiers()==VhdlSpecifier::USE
      ); // member should belong to something
  if (cd) d=cd;
  else if (nd) d=nd;
  else if (fd) d=fd;
  else if (mod) d=mod;
  else if (gd) d=gd;
  else d=mdef;
 
  // write search index info
  if (Doxygen::searchIndex.enabled())
  {
    Doxygen::searchIndex.setCurrentDoc(mdef,mdef->anchor(),false);
    Doxygen::searchIndex.addWord(mdef->localName(),true);
    Doxygen::searchIndex.addWord(mdef->qualifiedName(),false);
  }
 
  DString cname  = d->name();
  DString cfname = d->getOutputFileBase();
 
  //HtmlHelp *htmlHelp=nullptr;
  //  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
  const ClassDef *annoClassDef=mdef->getClassDefOfAnonymousType();
 
  // start a new member declaration
  OutputGenerator::MemberItemType memType = annoClassDef!=nullptr ? OutputGenerator::MemberItemType::AnonymousStart :
                                                              OutputGenerator::MemberItemType::Normal;
  ///printf("startMemberItem for %s\n",qPrint(name()));
  VhdlSpecifier mm=mdef->getVhdlSpecifiers();
  if (mm==VhdlSpecifier::MISCELLANEOUS)
      memType=OutputGenerator::MemberItemType::Templated;
 
   ol.startMemberItem( mdef->anchor(), memType );
 
  // If there is no detailed description we need to write the anchor here.
  bool detailsVisible = mdef->hasDetailedDescription();
  if (!detailsVisible)
  {
    DString doxyName=mdef->name();
    if (!cname.empty()) doxyName.prepend(cname+"::");
    DString doxyArgs=mdef->argsString();
    ol.startDoxyAnchor(cfname,cname,mdef->anchor(),doxyName,doxyArgs);
    ol.addLabel(cfname,mdef->anchor());
 
    ol.pushGeneratorState();
    ol.disable(OutputType::Man);
    ol.disable(OutputType::Latex);
    ol.docify("\n");
    ol.popGeneratorState();
 
  }
  // *** write type
  /*VHDL CHANGE */
 
  DString ltype(mdef->typeString());
  DString largs(mdef->argsString());
 
  ClassDef *kl=nullptr;
  const ArgumentList &al = mdef->argumentList();
  DString nn;
  //VhdlDocGen::adjustRecordMember(mdef);
  if (gd) gd=nullptr;
  switch (mm)
  {
    case VhdlSpecifier::MISCELLANEOUS:
      VhdlDocGen::writeSource(mdef,ol,nn);
      break;
    case VhdlSpecifier::PROCEDURE:
    case VhdlSpecifier::FUNCTION:
      ol.startBold();
      VhdlDocGen::formatString(ltype,ol,mdef);
      ol.endBold();
      ol.insertMemberAlign();
      ol.docify(" ");
 
      writeLink(mdef,ol);
      if (al.hasParameters() && mm==VhdlSpecifier::FUNCTION)
        VhdlDocGen::writeFunctionProto(ol,al,mdef);
 
      if (al.hasParameters() && mm==VhdlSpecifier::PROCEDURE)
        VhdlDocGen::writeProcedureProto(ol,al,mdef);
 
      break;
    case VhdlSpecifier::USE:
      kl=VhdlDocGen::getClass(mdef->name());
      if (kl && (VhdlDocGen::convert(kl->protection())==VhdlDocGen::ENTITYCLASS)) break;
      writeLink(mdef,ol);
      ol.insertMemberAlign();
      ol.docify("  ");
 
      if (kl)
      {
        nn=kl->getOutputFileBase();
        ol.pushGeneratorState();
        ol.disableAllBut(OutputType::Html);
        ol.docify(" ");
        DString name=theTranslator_vhdlType(VhdlSpecifier::PACKAGE,true);
        ol.startBold();
        ol.docify(name);
        name.clear();
        ol.endBold();
        name+=" <"+mdef->name()+">";
        ol.startEmphasis();
        ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),DString(),name);
        ol.popGeneratorState();
      }
      break;
    case VhdlSpecifier::LIBRARY:
      writeLink(mdef,ol);
      ol.insertMemberAlign();
      if (largs=="context")
      {
        VhdlDocGen::writeRecordUnit(ltype,largs,ol,mdef);
      }
 
      break;
 
    case VhdlSpecifier::GENERIC:
    case VhdlSpecifier::PORT:
    case VhdlSpecifier::ALIAS:
 
      writeLink(mdef,ol);
      ol.docify(" ");
      if (mm==VhdlSpecifier::GENERIC)
      {
        ol.insertMemberAlign();
        ol.startBold();
        VhdlDocGen::formatString(largs,ol,mdef);
        ol.endBold();
      }
      else
      {
        ol.insertMemberAlignLeft(memType, false);
        ol.docify(" ");
        ol.startBold();
        VhdlDocGen::formatString(ltype,ol,mdef);
        ol.endBold();
        ol.insertMemberAlign();
        ol.docify(" ");
        VhdlDocGen::formatString(largs,ol,mdef);
      }
      break;
    case VhdlSpecifier::PROCESS:
      writeLink(mdef,ol);
      ol.insertMemberAlign();
      VhdlDocGen::writeProcessProto(ol,al,mdef);
      break;
    case VhdlSpecifier::PACKAGE:
    case VhdlSpecifier::ENTITY:
    case VhdlSpecifier::COMPONENT:
    case VhdlSpecifier::INSTANTIATION:
    case VhdlSpecifier::CONFIG:
      if (VhdlDocGen::isCompInst(mdef) )
      {
        nn=largs;
        if(nn.stripPrefix("function") || nn.stripPrefix("package"))
        {
          VhdlDocGen::formatString(largs,ol,mdef);
          ol.insertMemberAlign();
          writeLink(mdef,ol);
          ol.docify(" ");
          VhdlDocGen::formatString(ltype,ol,mdef);
          break;
        }
 
        largs.prepend("::");
        largs.prepend(mdef->name());
        ol.writeObjectLink(mdef->getReference(),
            cfname,
            mdef->anchor(),
            mdef->name());
      }
      else
        writeLink(mdef,ol);
 
      ol.insertMemberAlign();
      ol.docify("  ");
      ol.startBold();
      ol.docify(ltype);
      ol.endBold();
      ol.docify("  ");
      if (VhdlDocGen::isComponent(mdef) ||
          VhdlDocGen::isConfig(mdef)    ||
          VhdlDocGen::isCompInst(mdef))
      {
        if (VhdlDocGen::isConfig(mdef) || VhdlDocGen::isCompInst(mdef))
        {
          nn=ltype;
        }
        else
        {
          nn=mdef->name();
        }
        kl=getClass(nn);
        if (kl)
        {
          nn=kl->getOutputFileBase();
          ol.pushGeneratorState();
          ol.disableAllBut(OutputType::Html);
          ol.startEmphasis();
          DString name("<Entity ");
          if (VhdlDocGen::isConfig(mdef) || VhdlDocGen::isCompInst(mdef))
          {
            name+=ltype+">";
          }
          else
          {
            name+=mdef->name()+"> ";
          }
          ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),DString(),name);
          ol.endEmphasis();
          ol.popGeneratorState();
        }
      }
      break;
    case VhdlSpecifier::UCF_CONST:
      writeUCFLink(mdef,ol);
      break;
    case VhdlSpecifier::SIGNAL:
    case VhdlSpecifier::ATTRIBUTE:
    case VhdlSpecifier::SUBTYPE:
    case VhdlSpecifier::CONSTANT:
    case VhdlSpecifier::SHAREDVARIABLE:
    case VhdlSpecifier::VFILE:
    case VhdlSpecifier::GROUP:
    case VhdlSpecifier::TYPE:
      writeLink(mdef,ol);
      ol.docify(" ");
      ol.insertMemberAlign();
      VhdlDocGen::formatString(ltype,ol,mdef);
      break;
    case VhdlSpecifier::RECORD:
    case VhdlSpecifier::UNITS:
     writeRecordUnit(largs,ltype,ol,mdef);
      break;
 
    default: break;
  }
 
  bool htmlOn = ol.isEnabled(OutputType::Html);
  if (htmlOn && /*Config_getBool(HTML_ALIGN_MEMBERS) &&*/ !ltype.empty())
  {
    ol.disable(OutputType::Html);
  }
  if (!ltype.empty()) ol.docify(" ");
 
  if (htmlOn)
  {
    ol.enable(OutputType::Html);
  }
 
  if (!detailsVisible)
  {
    ol.endDoxyAnchor(cfname,mdef->anchor());
  }
 
  ol.endMemberItem(memType);
  if (!mdef->briefDescription().empty() &&   Config_getBool(BRIEF_MEMBER_DESC) /* && !annMemb */)
  {
    DString s=mdef->briefDescription();
    ol.startMemberDescription(mdef->anchor(), DString(), mm == VhdlSpecifier::PORT);
    ol.generateDoc(mdef->briefFile(),
                   mdef->briefLine(),
                   mdef->getOuterScope()?mdef->getOuterScope():d,
                   mdef,
                   s,
                   DocOptions()
                   .setIndexWords(true)
                   .setSingleLine(true));
    if (detailsVisible)
    {
      ol.pushGeneratorState();
      ol.disableAllBut(OutputType::Html);
      ol.docify(" ");
      if (mdef->getGroupDef()!=nullptr && gd==nullptr) // forward link to the group
      {
        ol.startTextLink(mdef->getOutputFileBase(),mdef->anchor());
      }
      else // local link
      {
        ol.startTextLink(DString(),mdef->anchor());
      }
      ol.endTextLink();
      ol.popGeneratorState();
    }
    ol.endMemberDescription();
  }
  mdef->warnIfUndocumented();
 
}// end writeVhdlDeclaration

References OutputList::addLabel(), SearchIndexIntf::addWord(), ALIAS, Definition::anchor(), OutputGenerator::AnonymousStart, MemberDef::argsString(), MemberDef::argumentList(), ASSERT, ATTRIBUTE, Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), DString::clear(), COMPONENT, CONFIG, Config_getBool, CONSTANT, convert(), OutputList::disable(), OutputList::disableAllBut(), OutputList::docify(), DString::DString(), DString::empty(), OutputList::enable(), OutputList::endBold(), OutputList::endDoxyAnchor(), OutputList::endEmphasis(), OutputList::endMemberDescription(), OutputList::endMemberItem(), OutputList::endTextLink(), ENTITY, ENTITYCLASS, formatString(), FUNCTION, OutputList::generateDoc(), GENERIC, getClass(), MemberDef::getClassDefOfAnonymousType(), MemberDef::getGroupDef(), Definition::getOuterScope(), Definition::getOutputFileBase(), Definition::getReference(), MemberDef::getVhdlSpecifiers(), GROUP, MemberDef::hasDetailedDescription(), ArgumentList::hasParameters(), Html, OutputList::insertMemberAlign(), OutputList::insertMemberAlignLeft(), INSTANTIATION, isCompInst(), isComponent(), isConfig(), OutputList::isEnabled(), Latex, LIBRARY, Definition::localName(), Man, MISCELLANEOUS, Definition::name(), OutputGenerator::Normal, PACKAGE, OutputList::popGeneratorState(), PORT, DString::prepend(), PROCEDURE, PROCESS, ClassDef::protection(), OutputList::pushGeneratorState(), Definition::qualifiedName(), RECORD, Doxygen::searchIndex, SearchIndexIntf::setCurrentDoc(), SHAREDVARIABLE, SIGNAL, OutputList::startBold(), OutputList::startDoxyAnchor(), OutputList::startEmphasis(), OutputList::startMemberDescription(), OutputList::startMemberItem(), OutputList::startTextLink(), DString::stripPrefix(), SUBTYPE, OutputGenerator::Templated, theTranslator_vhdlType, TYPE, MemberDef::typeString(), UCF_CONST, UNITS, USE, VFILE, MemberDef::warnIfUndocumented(), writeFunctionProto(), writeLink(), OutputList::writeObjectLink(), writeProcedureProto(), writeProcessProto(), writeRecordUnit(), writeSource(), and writeUCFLink().

Referenced by writePlainVHDLDeclarations(), and writeRecordProto().

writeVHDLDeclarations()

void VhdlDocGen::writeVHDLDeclarations ( const MemberList * ml, OutputList & ol, const ClassDef * cd, const NamespaceDef * nd, const FileDef * fd, const GroupDef * gd, const ModuleDef * mod, const DString & title, const DString & subtitle, bool showEnumValues, VhdlSpecifier type )

static

Definition at line 1746 of file vhdldocgen.cpp.

{
  if (!membersHaveSpecificType(ml,type)) return;
 
  if (!title.empty())
  {
    ol.startMemberHeader(convertToId(title),type == VhdlSpecifier::PORT ? 3 : 2);
    ol.parseText(title);
    ol.endMemberHeader();
    ol.docify(" ");
  }
  if (!subtitle.empty())
  {
    ol.startMemberSubtitle();
    ol.generateDoc("[generated]",
                   -1,
                   nullptr,
                   nullptr,
                   subtitle,
                   DocOptions()
                   .setSingleLine(true));
    ol.endMemberSubtitle();
  } //printf("memberGroupList=%p\n",memberGroupList);
 
  VhdlDocGen::writePlainVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,type);
 
  int groupId=0;
  for (const auto &mg : ml->getMemberGroupList())
  {
    if (membersHaveSpecificType(&mg->members(),type))
    {
      //printf("mg->header=%s\n",qPrint(mg->header()));
      bool hasHeader=!mg->header().empty();
      DString groupAnchor = DString(ml->listType().toLabel())+"-"+DString().setNum(groupId++);
      ol.startMemberGroupHeader(groupAnchor,hasHeader);
      if (hasHeader)
      {
        ol.parseText(mg->header());
      }
      ol.endMemberGroupHeader(hasHeader);
      if (!mg->documentation().empty())
      {
        //printf("Member group has docs!\n");
        ol.startMemberGroupDocs();
        ol.generateDoc("[generated]",
                       -1,
                       nullptr,
                       nullptr,
                       mg->documentation()+"\n",
                       DocOptions());
        ol.endMemberGroupDocs();
      }
      ol.startMemberGroup();
      //printf("--- mg->writePlainDeclarations ---\n");
      VhdlDocGen::writePlainVHDLDeclarations(&mg->members(),ol,cd,nd,fd,gd,mod,type);
      ol.endMemberGroup(hasHeader);
    }
  }
}// writeVHDLDeclarations

References convertToId(), OutputList::docify(), DString::DString(), DString::empty(), OutputList::endMemberGroup(), OutputList::endMemberGroupDocs(), OutputList::endMemberGroupHeader(), OutputList::endMemberHeader(), OutputList::endMemberSubtitle(), OutputList::generateDoc(), MemberList::getMemberGroupList(), MemberList::listType(), membersHaveSpecificType(), OutputList::parseText(), PORT, DString::setNum(), OutputList::startMemberGroup(), OutputList::startMemberGroupDocs(), OutputList::startMemberGroupHeader(), OutputList::startMemberHeader(), OutputList::startMemberSubtitle(), MemberListType::toLabel(), and writePlainVHDLDeclarations().

Referenced by writeRecordProto(), and writeVhdlDeclarations().

writeVhdlDeclarations()

void VhdlDocGen::writeVhdlDeclarations ( const MemberList * ml, OutputList & ol, const GroupDef * gd, const ClassDef * cd, const FileDef * fd, const NamespaceDef * nd, const ModuleDef * mod )

static

Definition at line 1180 of file vhdldocgen.cpp.

{
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::LIBRARY,false),DString(),false,VhdlSpecifier::LIBRARY);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::USE,false),DString(),false,VhdlSpecifier::USE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::FUNCTION,false),DString(),false,VhdlSpecifier::FUNCTION);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::COMPONENT,false),DString(),false,VhdlSpecifier::COMPONENT);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::CONSTANT,false),DString(),false,VhdlSpecifier::CONSTANT);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::TYPE,false),DString(),false,VhdlSpecifier::TYPE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::SUBTYPE,false),DString(),false,VhdlSpecifier::SUBTYPE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::GENERIC,false),DString(),false,VhdlSpecifier::GENERIC);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::PORT,false),DString(),false,VhdlSpecifier::PORT);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::PROCESS,false),DString(),false,VhdlSpecifier::PROCESS);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::SIGNAL,false),DString(),false,VhdlSpecifier::SIGNAL);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::ATTRIBUTE,false),DString(),false,VhdlSpecifier::ATTRIBUTE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::PROCEDURE,false),DString(),false,VhdlSpecifier::PROCEDURE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::RECORD,false),DString(),false,VhdlSpecifier::RECORD);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::UNITS,false),DString(),false,VhdlSpecifier::UNITS);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::SHAREDVARIABLE,false),DString(),false,VhdlSpecifier::SHAREDVARIABLE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::VFILE,false),DString(),false,VhdlSpecifier::VFILE);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::GROUP,false),DString(),false,VhdlSpecifier::GROUP);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::INSTANTIATION,false),DString(),false,VhdlSpecifier::INSTANTIATION);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::ALIAS,false),DString(),false,VhdlSpecifier::ALIAS);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::MISCELLANEOUS,true),DString(),false,VhdlSpecifier::MISCELLANEOUS);
 
  // configurations must be added to global file definitions.
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::CONFIG,false),DString(),false,VhdlSpecifier::CONFIG);
  VhdlDocGen::writeVHDLDeclarations(ml,ol,cd,nd,fd,gd,mod,theTranslator_vhdlType(VhdlSpecifier::UCF_CONST,false),DString(),false,VhdlSpecifier::UCF_CONST);
 
}

References ALIAS, ATTRIBUTE, COMPONENT, CONFIG, CONSTANT, DString::DString(), FUNCTION, GENERIC, GROUP, INSTANTIATION, LIBRARY, MISCELLANEOUS, PORT, PROCEDURE, PROCESS, RECORD, SHAREDVARIABLE, SIGNAL, SUBTYPE, theTranslator_vhdlType, TYPE, UCF_CONST, UNITS, USE, VFILE, and writeVHDLDeclarations().

Referenced by MemberList::writeDeclarations(), ClassDefImpl::writeMemberDeclarations(), FileDefImpl::writeMemberDeclarations(), GroupDefImpl::writeMemberDeclarations(), and writeRecordProto().

writeVhdlLink()

void VhdlDocGen::writeVhdlLink ( const ClassDef * cdd, OutputList & ol, DString & type, DString & name, DString & beh )

staticprivate

Definition at line 567 of file vhdldocgen.cpp.

{
  if (ccd==nullptr)  return;
  ol.startBold();
  ol.docify(type);
  ol.endBold();
  nn.stripPrefix("_");
  ol.writeObjectLink(ccd->getReference(),ccd->getOutputFileBase(),DString(),nn);
 
  if (!behav.empty())
  {
    behav.prepend("  ");
    ol.startBold();
    ol.docify(behav);
    ol.endBold();
  }
 
  ol.lineBreak();
}

References OutputList::docify(), DString::empty(), OutputList::endBold(), Definition::getOutputFileBase(), Definition::getReference(), OutputList::lineBreak(), DString::prepend(), OutputList::startBold(), DString::stripPrefix(), and OutputList::writeObjectLink().

Referenced by compareArgList(), and writeInlineClassLink().

writeVHDLTypeDocumentation()

bool VhdlDocGen::writeVHDLTypeDocumentation ( const MemberDef * mdef, const Definition * d, OutputList & ol )

static

Definition at line 1259 of file vhdldocgen.cpp.

{
  const ClassDef *cd=toClassDef(d);
  bool hasParams = false;
 
  if (cd==nullptr) return hasParams;
 
  DString ttype=mdef->typeString();
  DString largs=mdef->argsString();
 
  if ((VhdlDocGen::isVhdlFunction(mdef) || VhdlDocGen::isProcedure(mdef) || VhdlDocGen::isProcess(mdef)))
  {
    DString nn=mdef->typeString();
    nn=nn.stripWhiteSpace();
    DString na=cd->name();
    const MemberDef* memdef=VhdlDocGen::findMember(na,nn);
    if (memdef && memdef->isLinkable())
    {
      ol.docify(" ");
 
      ol.startBold();
      writeLink(memdef,ol);
      ol.endBold();
      ol.docify(" ");
    }
    else
    {
      ol.docify(" ");
      VhdlDocGen::formatString(ttype,ol,mdef);
      ol.docify(" ");
    }
    ol.docify(mdef->name());
    hasParams = VhdlDocGen::writeFuncProcDocu(mdef,ol, mdef->argumentList());
  }
 
 
  if (mdef->isVariable())
  {
    if (VhdlDocGen::isConstraint(mdef))
    {
      writeLink(mdef,ol);
      ol.docify(" ");
 
      largs=substitute(largs,"#"," ");
      VhdlDocGen::formatString(largs,ol,mdef);
      return hasParams;
    }
    else
    {
      writeLink(mdef,ol);
      if (VhdlDocGen::isLibrary(mdef) || VhdlDocGen::isPackage(mdef))
      {
        return hasParams;
      }
      ol.docify(" ");
    }
 
    // DString largs=mdef->argsString();
 
    bool c=largs=="context";
    bool brec=largs.stripPrefix("record")  ;
 
    if (!brec && !c)
      VhdlDocGen::formatString(ttype,ol,mdef);
 
    if (c || brec || largs.stripPrefix("units"))
    {
      if (c)
          largs=ttype;
      VhdlDocGen::writeRecUnitDocu(mdef,ol,largs);
      return hasParams;
    }
 
    ol.docify(" ");
    if (VhdlDocGen::isPort(mdef) || VhdlDocGen::isGeneric(mdef))
    {
      // DString largs=mdef->argsString();
      VhdlDocGen::formatString(largs,ol,mdef);
      ol.docify(" ");
    }
  }
  return hasParams;
}

References MemberDef::argsString(), MemberDef::argumentList(), OutputList::docify(), OutputList::endBold(), findMember(), formatString(), isConstraint(), isGeneric(), isLibrary(), Definition::isLinkable(), isPackage(), isPort(), isProcedure(), isProcess(), MemberDef::isVariable(), isVhdlFunction(), Definition::name(), OutputList::startBold(), DString::stripPrefix(), DString::stripWhiteSpace(), substitute(), toClassDef(), MemberDef::typeString(), writeFuncProcDocu(), writeLink(), and writeRecUnitDocu().

Referenced by MemberDefImpl::writeDocumentation(), and writeRecordProto().

---

The documentation for this class was generated from the following files:

• src/vhdldocgen.h
• src/vhdldocgen.cpp