#include "vhdldocgen.h"
#include <algorithm>
#include <map>
#include <mutex>
#include <unordered_set>
#include "arguments.h"
#include "classlist.h"
#include "commentscan.h"
#include "config.h"
#include "definition.h"
#include "doxygen.h"
#include "dstring.h"
#include "filename.h"
#include "groupdef.h"
#include "language.h"
#include "memberdef.h"
#include "membergroup.h"
#include "memberlist.h"
#include "membername.h"
#include "message.h"
#include "moduledef.h"
#include "namespacedef.h"
#include "outputlist.h"
#include "parserintf.h"
#include "plantuml.h"
#include "portable.h"
#include "regex.h"
#include "stringutil.h"
#include "textstream.h"
#include "util.h"
#include "vhdljjparser.h"

Include dependency graph for vhdldocgen.cpp:

Classes
struct	[struct].flowCol

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

Functions
static void	initUCF (Entry *root, const DString &type, DString &qcs, int line, const DString &fileName, DString &brief)
static void	writeUCFLink (const MemberDef *mdef, OutputList &ol)
static void	addInstance (ClassDefMutable entity, ClassDefMutable arch, ClassDefMutable *inst, const std::shared_ptr< Entry > &cur)
static void	writeLink (const MemberDef *mdef, OutputList &ol)
static void	startFonts (const DString &q, const char *keyword, OutputList &ol)
static DString	splitString (DString &str, char c)
static int	compareString (const DString &s1, const DString &s2)
static VhdlSpecifier	getSpecifierTypeFromClass (const ClassDef *cd)
static bool	membersHaveSpecificType (const MemberList *ml, VhdlSpecifier type)
static const MemberDef *	findMemFlow (const MemberDef *mdef)
static void	alignText (DString &q)

Variables
static const MemberDef *	flowMember =nullptr
static const std::unordered_set< std::string >	g_vhdlKeyWordSet0
static const std::unordered_set< std::string >	g_vhdlKeyWordSet1
static const std::unordered_set< std::string >	g_vhdlKeyWordSet2
static const std::unordered_set< std::string >	g_vhdlKeyWordSet3
static std::recursive_mutex	g_vhdlMutex
static std::map< std::string, const MemberDef * >	g_varMap
static std::vector< ClassDef * >	g_classList
static std::map< ClassDef , std::vector< ClassDef > >	g_packages
static int	recordCounter =0
static std::vector< const MemberDef * >	mdList
static int	ifcounter =0
static int	nodeCounter =0
static struct	flowCol
std::vector< FlowChart >	flowList

Macro Definition Documentation

◆ DECLN

#define DECLN

Value:

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

Definition at line 2489 of file vhdldocgen.cpp.

Referenced by FlowChart::writeShape().

◆ EE

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

Definition at line 2501 of file vhdldocgen.cpp.

◆ EEND

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

Definition at line 2497 of file vhdldocgen.cpp.

Referenced by FlowChart::writeFlowLinks(), and FlowChart::writeShape().

◆ EMPTNODE

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

Definition at line 2502 of file vhdldocgen.cpp.

Referenced by FlowChart::printNode().

◆ EMPTY

#define EMPTY (EEND | FlowChart::ELSIF_NO)

Definition at line 2500 of file vhdldocgen.cpp.

Referenced by FlowChart::colTextNodes().

◆ ENDCL

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

Definition at line 2496 of file vhdldocgen.cpp.

Referenced by FlowChart::writeShape().

◆ EXITNEXT

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

Definition at line 2499 of file vhdldocgen.cpp.

Referenced by FlowChart::writeShape().

◆ FLOWLEN

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

Definition at line 2503 of file vhdldocgen.cpp.

Referenced by FlowChart::buildCommentNodes(), FlowChart::getNextNode(), and FlowChart::printUmlTree().

◆ IFF

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

Definition at line 2498 of file vhdldocgen.cpp.

Referenced by FlowChart::colTextNodes(), FlowChart::writeFlowLinks(), and FlowChart::writeShape().

◆ LOOP

#define LOOP

Value:

(FlowChart::FOR_NO | FlowChart::WHILE_NO | \

FlowChart::LOOP_NO )

Definition at line 2494 of file vhdldocgen.cpp.

Referenced by FlowChart::findLabel(), FlowChart::findPrevLoop(), and FlowChart::writeShape().

◆ STARTFIN

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

Definition at line 2493 of file vhdldocgen.cpp.

Referenced by FlowChart::writeShape().

◆ STARTL

#define STARTL

Value:

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

Definition at line 2486 of file vhdldocgen.cpp.

Referenced by FlowChart::FlowChart(), FlowChart::printNode(), and FlowChart::writeEdge().

◆ theTranslator_vhdlType

#define theTranslator_vhdlType theTranslator->trVhdlType

Definition at line 60 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::getClassTitle(), VhdlDocGen::writeInlineClassLink(), VhdlDocGen::writeVHDLDeclaration(), and VhdlDocGen::writeVhdlDeclarations().

Function Documentation

◆ addInstance()

void addInstance	(	ClassDefMutable *	entity,
		ClassDefMutable *	arch,
		ClassDefMutable *	inst,
		const std::shared_ptr< Entry > &	cur )

static

Definition at line 2177 of file vhdldocgen.cpp.

{
 
  DString bName,n1;
  if (ar==nullptr) return;
 
  if (classEntity==nullptr)
  {
    //add component inst
    n1=cur->type;
    goto ferr;
  }
 
  if (classEntity==cd) return;
 
  bName=classEntity->name();
  // fprintf(stderr,"\naddInstance %s to %s %s %s\n",qPrint( classEntity->name()),qPrint(cd->name()),qPrint(ar->name()),cur->name);
  n1=classEntity->name();
 
  if (!cd->isBaseClass(classEntity, true))
  {
    cd->insertBaseClass(classEntity,n1,Protection::Public,Specifier::Normal,DString());
  }
  else
  {
    VhdlDocGen::addBaseClass(cd,classEntity);
  }
 
  if (!VhdlDocGen::isSubClass(classEntity,cd,true,0))
  {
    classEntity->insertSubClass(cd,Protection::Public,Specifier::Normal,DString());
    classEntity->setLanguage(SrcLangExt::VHDL);
  }
 
ferr:
  DString uu=cur->name;
  auto md = createMemberDef(
      ar->getDefFileName(), cur->startLine,cur->startColumn,
      n1,uu,uu, DString(),
      Protection::Public,
      Specifier::Normal,
      cur->isStatic,
      Relationship::Member,
      MemberType::Variable,
      ArgumentList(),
      ArgumentList(),
      "");
  auto mmd = toMemberDefMutable(md.get());
 
  if (!ar->getOutputFileBase().empty())
  {
    TagInfo tg;
    tg.anchor = nullptr;
    tg.fileName = ar->getOutputFileBase();
    tg.tagName = nullptr;
    mmd->setTagInfo(&tg);
  }
 
  //fprintf(stderr,"\n%s%s%s\n",qPrint(md->name()),qPrint(cur->brief),qPrint(cur->doc));
 
  mmd->setLanguage(SrcLangExt::VHDL);
  mmd->setVhdlSpecifiers(VhdlSpecifier::INSTANTIATION);
  mmd->setBriefDescription(cur->brief,cur->briefFile,cur->briefLine);
  mmd->setBodySegment(cur->startLine,cur->startLine,-1) ;
  mmd->setDocumentation(cur->doc,cur->docFile,cur->docLine);
  FileDef *fd=ar->getFileDef();
  mmd->setBodyDef(fd);
  ar->insertMember(md.get());
  MemberName *mn = Doxygen::functionNameLinkedMap->add(uu);
  mn->push_back(std::move(md));
 
}

References LinkedMap< T, Hash, KeyEqual, Map >::add(), VhdlDocGen::addBaseClass(), TagInfo::anchor, createMemberDef(), DString::empty(), TagInfo::fileName, Doxygen::functionNameLinkedMap, Definition::getDefFileName(), ClassDef::getFileDef(), Definition::getOutputFileBase(), ClassDefMutable::insertBaseClass(), ClassDefMutable::insertMember(), ClassDefMutable::insertSubClass(), INSTANTIATION, ClassDef::isBaseClass(), VhdlDocGen::isSubClass(), Definition::name(), MemberName::push_back(), DefinitionMutable::setBodyDef(), DefinitionMutable::setLanguage(), TagInfo::tagName, and toMemberDefMutable().

Referenced by VhdlDocGen::computeVhdlComponentRelations().

◆ alignText()

void alignText ( DString & q )

static

Definition at line 2538 of file vhdldocgen.cpp.

{
  if (q.length()<=80) return;
 
  if (q.length()>200)
  {
    q.resize(200);
  }
 
  q.append(" ...");
 
  DString str(q);
  DString temp;
 
  while (str.length()>80)
  {
    size_t j0 = str.rfind(' ',80);
    size_t j1 = str.rfind('|',80);
    size_t j =  j0!=DString::npos && j1!=DString::npos ? std::max(j0,j1) :
                j0!=DString::npos ? j0 : j1;
    if (j==DString::npos || j==0)
    {
      temp+=str;
      q=temp;
      return;
    }
    else
    {
      DString qcs=str.left(j);
      temp+=qcs+"\\";
      temp+="n";
      str.remove(0,j);
    }
  }//while
 
 q=temp+str;
// #endif
}

References DString::append(), DString::left(), DString::length(), DString::npos, DString::remove(), DString::resize(), and DString::rfind().

Referenced by FlowChart::writeShape().

◆ compareString()

int compareString	(	const DString &	s1,
		const DString &	s2 )

static

Definition at line 109 of file vhdldocgen.cpp.

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

References dstricmp(), and DString::stripWhiteSpace().

Referenced by VhdlDocGen::findFunction().

◆ findMemFlow()

const MemberDef * findMemFlow ( const MemberDef * mdef )

static

Definition at line 2375 of file vhdldocgen.cpp.

{
  for (const auto &md : mdList)
  {
    if (md->name()==mdef->name() &&  md->getStartBodyLine()==mdef->getStartBodyLine())
    {
      return md;
    }
  }
  return nullptr;
}

References Definition::getStartBodyLine(), mdList, and Definition::name().

Referenced by VhdlDocGen::createFlowChart().

◆ getSpecifierTypeFromClass()

VhdlSpecifier getSpecifierTypeFromClass ( const ClassDef * cd )

static

Definition at line 406 of file vhdldocgen.cpp.

{
  VhdlDocGen::VhdlClasses ii=VhdlDocGen::convert(cd->protection());
 
  DString type;
  if (ii==VhdlDocGen::ENTITYCLASS)
    return VhdlSpecifier::ENTITY;
  else if (ii==VhdlDocGen::ARCHITECTURECLASS)
    return VhdlSpecifier::ARCHITECTURE;
  else if (ii==VhdlDocGen::PACKBODYCLASS)
    return VhdlSpecifier::PACKAGE_BODY;
  else if (ii==VhdlDocGen::PACKAGECLASS)
    return VhdlSpecifier::PACKAGE;
  return VhdlSpecifier::UNKNOWN;
}

References ARCHITECTURE, VhdlDocGen::ARCHITECTURECLASS, VhdlDocGen::convert(), ENTITY, VhdlDocGen::ENTITYCLASS, PACKAGE, PACKAGE_BODY, VhdlDocGen::PACKAGECLASS, VhdlDocGen::PACKBODYCLASS, ClassDef::protection(), and UNKNOWN.

Referenced by VhdlDocGen::getClassTitle(), VhdlDocGen::writeClassType(), and VhdlDocGen::writeInlineClassLink().

◆ initUCF()

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

static

Definition at line 1965 of file vhdldocgen.cpp.

{
  if (qcs.empty())return;
  DString n;
 
  VhdlDocGen::deleteAllChars(qcs,';');
  qcs=qcs.stripWhiteSpace();
 
  static const reg::Ex reg(R"([\s=])");
  size_t i = findIndex(qcs.str(),reg);
  if (i==std::string::npos) return;
  if (i==0)
  {
    n=type;
    VhdlDocGen::deleteAllChars(n,'#');
  }
  else
  {
    n=qcs.left(i);
  }
  qcs=qcs.remove(0,i+1);
  //  qcs.prepend("|");
 
  qcs.stripPrefix("=");
 
  std::shared_ptr<Entry> current = std::make_shared<Entry>();
  current->vhdlSpec=VhdlSpecifier::UCF_CONST;
  current->section=EntryType::makeVariable();
  current->bodyLine=line;
  current->fileName=fileName;
  current->type="ucf_const";
  current->args+=qcs;
  current->lang=  SrcLangExt::VHDL ;
 
  // adding dummy name for constraints like VOLTAGE=5,TEMPERATURE=20 C
  if (n.empty())
  {
    n="dummy";
    n+=VhdlDocGen::getRecordNumber();
  }
 
  current->name= n+"_";
  current->name.append(VhdlDocGen::getRecordNumber());
 
  if (!brief.empty())
  {
    current->brief=brief;
    current->briefLine=line;
    current->briefFile=fileName;
    brief.clear();
  }
 
  root->moveToSubEntryAndKeep(current);
}

References DString::append(), DString::clear(), VhdlDocGen::deleteAllChars(), DString::empty(), findIndex(), VhdlDocGen::getRecordNumber(), DString::left(), Entry::moveToSubEntryAndKeep(), DString::remove(), DString::str(), DString::stripPrefix(), DString::stripWhiteSpace(), and UCF_CONST.

Referenced by VhdlDocGen::parseUCF().

◆ membersHaveSpecificType()

bool membersHaveSpecificType	(	const MemberList *	ml,
		VhdlSpecifier	type )

static

Definition at line 1720 of file vhdldocgen.cpp.

{
  if (ml==nullptr) return false;
  for (const auto &mdd : *ml)
  {
    if (mdd->getVhdlSpecifiers()==type) //is type in class
    {
      return true;
    }
  }
  for (const auto &mg : ml->getMemberGroupList())
  {
    if (!mg->members().empty())
    {
      if (membersHaveSpecificType(&mg->members(),type)) return true;
    }
  }
  return false;
}

References MemberList::getMemberGroupList(), and membersHaveSpecificType().

Referenced by membersHaveSpecificType(), and VhdlDocGen::writeVHDLDeclarations().

◆ splitString()

DString splitString	(	DString &	str,
		char	c )

static

Definition at line 97 of file vhdldocgen.cpp.

{
  DString n=str;
  size_t i=str.find(c);
  if (i!=DString::npos && i>0)
  {
    n=str.left(i);
    str=str.remove(0,i+1);
  }
  return n;
}

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

Referenced by writeUCFLink().

◆ startFonts()

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

static

Definition at line 89 of file vhdldocgen.cpp.

{
  auto &codeOL = ol.codeGenerators();
  codeOL.startFontClass(keyword);
  codeOL.codify(q);
  codeOL.endFontClass();
}

References OutputList::codeGenerators(), and OutputCodeList::startFontClass().

Referenced by VhdlDocGen::writeFormatString(), VhdlDocGen::writeFuncProcDocu(), VhdlDocGen::writeFunctionProto(), VhdlDocGen::writeProcedureProto(), and VhdlDocGen::writeStringLink().

◆ writeLink()

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

static

Definition at line 81 of file vhdldocgen.cpp.

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

References Definition::anchor(), Definition::getOutputFileBase(), Definition::getReference(), Definition::name(), and OutputList::writeObjectLink().

Referenced by VhdlDocGen::writeRecordUnit(), VhdlDocGen::writeSource(), VhdlDocGen::writeStringLink(), writeUCFLink(), VhdlDocGen::writeVHDLDeclaration(), and VhdlDocGen::writeVHDLTypeDocumentation().

◆ writeUCFLink()

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

static

Definition at line 2022 of file vhdldocgen.cpp.

{
 
  DString largs(mdef->argsString());
  DString n= splitString(largs, '#');
  // VhdlDocGen::adjustRecordMember(mdef);
  bool equ=(n.length()==largs.length());
 
  if (!equ)
  {
    ol.writeString(n);
    ol.docify(" ");
    ol.insertMemberAlign();
  }
 
  if (mdef->name().contains("dummy")==0)
  {
    writeLink(mdef,ol);
  }
  if (equ)
  {
    ol.insertMemberAlign();
  }
  ol.docify(" ");
  VhdlDocGen::formatString(largs,ol,mdef);
}

References MemberDef::argsString(), DString::contains(), OutputList::docify(), VhdlDocGen::formatString(), OutputList::insertMemberAlign(), DString::length(), Definition::name(), splitString(), writeLink(), and OutputList::writeString().

Referenced by VhdlDocGen::writeVHDLDeclaration().

Variable Documentation

◆ flowCol

struct [struct].flowCol flowCol

Initial value:

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

Referenced by FlowChart::buildCommentNodes(), FlowChart::writeEdge(), and FlowChart::writeShape().

◆ flowList

std::vector<FlowChart> flowList

Definition at line 2532 of file vhdldocgen.cpp.

Referenced by FlowChart::addFlowChart(), FlowChart::buildCommentNodes(), FlowChart::colTextNodes(), FlowChart::delFlowList(), FlowChart::findLabel(), FlowChart::findNextLoop(), FlowChart::findNode(), FlowChart::findPrevLoop(), FlowChart::getNextIfLink(), FlowChart::getNextNode(), FlowChart::printFlowTree(), FlowChart::printUmlTree(), FlowChart::writeFlowChart(), and FlowChart::writeFlowLinks().

◆ flowMember

const MemberDef* flowMember =nullptr

static

Definition at line 67 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::getFlowMember(), and VhdlDocGen::setFlowMember().

◆ g_classList

std::vector<ClassDef*> g_classList

static

Definition at line 206 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findMemberDef(), and VhdlDocGen::resetCodeVhdlParserState().

◆ g_packages

std::map<ClassDef*,std::vector<ClassDef*> > g_packages

static

Definition at line 207 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findAllPackages(), VhdlDocGen::findMember(), and VhdlDocGen::resetCodeVhdlParserState().

◆ g_varMap

std::map<std::string,const MemberDef*> g_varMap

static

Definition at line 205 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findMemberDef(), and VhdlDocGen::resetCodeVhdlParserState().

◆ g_vhdlKeyWordSet0

const std::unordered_set< std::string > g_vhdlKeyWordSet0

static

Initial value:

                                                  =
{
  "abs","access","after","alias","all","and","architecture","array","assert","assume","assume_guarantee","attribute",
  "begin","block","body","buffer","bus",
  "case","component","configuration","constant","context","cover",
  "default","disconnect","downto",
  "else","elsif","end","entity","exit",
  "fairness","file","for","force","function",
  "generate","generic","group","guarded",
  "if","impure","in","inertial","inout","is",
  "label","library","linkage","literal","loop",
  "map","mod",
  "nand","new","next","nor","not","null",
  "of","on","open","or","others","out",
  "package","parameter","port","postponed","procedure","process","property","protected","pure",
  "range","record","register","reject","release","restrict","restrict_guarantee","rem","report","rol","ror","return",
  "select","sequence","severity","signal","shared","sla","sll","sra","srl","strong","subtype",
  "then","to","transport","type",
  "unaffected","units","until","use",
  "variable","vmode","vprop","vunit",
  "wait","when","while","with",
  "xor","xnor"
}

Definition at line 117 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findKeyWord().

◆ g_vhdlKeyWordSet1

const std::unordered_set< std::string> g_vhdlKeyWordSet1

static

Initial value:

                                                  =
{
  "natural","unsigned","signed","string","boolean", "bit","bit_vector","character",
  "std_ulogic","std_ulogic_vector","std_logic","std_logic_vector","integer",
  "real","float","ufixed","sfixed","time","positive"
}

Definition at line 143 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findKeyWord().

◆ g_vhdlKeyWordSet2

const std::unordered_set< std::string > g_vhdlKeyWordSet2

static

Initial value:

                                                  =
{
  "abs","and","or","not","mod","xor","rem","xnor","ror","rol","sla","sll"
}

Definition at line 151 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findKeyWord().

◆ g_vhdlKeyWordSet3

const std::unordered_set< std::string > g_vhdlKeyWordSet3

static

Initial value:

                                                  =
{
  "base","left","right","high","low","ascending",
  "image","value","pos","val","succ","pred","leftof","rightof","left","right","high","low",
  "range","reverse_range","length","ascending","delayed","stable","quiet","transaction","event",
  "active","last_event","last_active","last_value","driving","driving_value","simple_name","instance_name","path_name"
}

Definition at line 157 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findKeyWord().

◆ g_vhdlMutex

std::recursive_mutex g_vhdlMutex

static

Definition at line 204 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::findAllPackages(), VhdlDocGen::findMember(), VhdlDocGen::findMemberDef(), and VhdlDocGen::resetCodeVhdlParserState().

◆ ifcounter

int ifcounter =0

static

Definition at line 2505 of file vhdldocgen.cpp.

Referenced by FlowChart::delFlowList(), FlowChart::FlowChart(), and FlowChart::moveToPrevLevel().

◆ mdList

std::vector<const MemberDef*> mdList

static

Definition at line 2373 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::createFlowChart(), and findMemFlow().

◆ nodeCounter

int nodeCounter =0

static

Definition at line 2506 of file vhdldocgen.cpp.

Referenced by FlowChart::delFlowList(), and FlowChart::FlowChart().

◆ recordCounter

int recordCounter =0

static

Definition at line 729 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::getRecordNumber().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ DECLN

◆ EE

◆ EEND

◆ EMPTNODE

◆ EMPTY

◆ ENDCL

◆ EXITNEXT

◆ FLOWLEN

◆ IFF

◆ LOOP

◆ STARTFIN

◆ STARTL

◆ theTranslator_vhdlType

Function Documentation

◆ addInstance()

◆ alignText()

◆ compareString()

◆ findMemFlow()

◆ getSpecifierTypeFromClass()

◆ initUCF()

◆ membersHaveSpecificType()

◆ splitString()

◆ startFonts()

◆ writeLink()

◆ writeUCFLink()

Variable Documentation

◆ flowCol

◆ flowList

◆ flowMember

◆ g_classList

◆ g_packages

◆ g_varMap

◆ g_vhdlKeyWordSet0

◆ g_vhdlKeyWordSet1

◆ g_vhdlKeyWordSet2

◆ g_vhdlKeyWordSet3

◆ g_vhdlMutex

◆ ifcounter

◆ mdList

◆ nodeCounter

◆ recordCounter