Skip to main content

The vhdldocgen.cpp File Reference

Included Headers​

#include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h> #include <map> #include <algorithm> #include <unordered_set> #include <mutex> #include "qcstring.h" #include "vhdldocgen.h" #include "message.h" #include "config.h" #include "doxygen.h" #include "util.h" #include "language.h" #include "commentscan.h" #include "definition.h" #include "searchindex.h" #include "outputlist.h" #include "parserintf.h" #include "layout.h" #include "arguments.h" #include "portable.h" #include "memberlist.h" #include "memberdef.h" #include "groupdef.h" #include "classlist.h" #include "namespacedef.h" #include "filename.h" #include "membergroup.h" #include "membername.h" #include "plantuml.h" #include "vhdljjparser.h" #include "VhdlParser.h" #include "regex.h" #include "textstream.h" #include "moduledef.h"

Functions Index​

static voidinitUCF (Entry *root, const QCString &type, QCString &qcs, int line, const QCString &fileName, QCString &brief)
static voidwriteUCFLink (const MemberDef *mdef, OutputList &ol)
static voidaddInstance (ClassDefMutable *entity, ClassDefMutable *arch, ClassDefMutable *inst, const std::shared_ptr< Entry > &cur)
static voidwriteLink (const MemberDef *mdef, OutputList &ol)
static voidstartFonts (const QCString &q, const char *keyword, OutputList &ol)
static QCStringsplitString (QCString &str, char c)
static intcompareString (const QCString &s1, const QCString &s2)
static VhdlSpecifiergetSpecifierTypeFromClass (const ClassDef *cd)
static boolmembersHaveSpecificType (const MemberList *ml, VhdlSpecifier type)
static const MemberDef *findMemFlow (const MemberDef *mdef)
voidalignText (QCString &q)

Variables Index​

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_mutexg_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 intrecordCounter =0
static std::vector< const MemberDef * >mdList
static intifcounter =0
static intnodeCounter =0
const char *textNodeLink
const char *yesNodeLink
const char *noNodeLink
const char *comment
const char *decisionNode
const char *varNode
const char *startEndNode
const char *textNode
struct { ... }flowCol = ...
std::vector< FlowChart >flowList

Macro Definitions Index​

#definetheTranslator_vhdlType   theTranslator->trVhdlType
#defineSTARTL   ...
#defineDECLN   ...
#defineSTARTFIN   (FlowChart::START_NO | FlowChart::END_NO)
#defineLOOP   ...
#defineENDCL   (FlowChart::END_CASE | FlowChart::END_LOOP)
#defineEEND   (FlowChart::ENDIF_NO | FlowChart::ELSE_NO )
#defineIFF   (FlowChart::ELSIF_NO | FlowChart::IF_NO)
#defineEXITNEXT   (FlowChart::EXIT_NO | FlowChart::NEXT_NO )
#defineEMPTY   (EEND | FlowChart::ELSIF_NO)
#defineEE   (FlowChart::ELSE_NO | FlowChart::ELSIF_NO)
#defineEMPTNODE   (ENDCL | EEND | FlowChart::ELSIF_NO)
#defineFLOWLEN   (flowList.size()-1)

Functions​

addInstance()​

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

Definition at line 2191 of file vhdldocgen.cpp.

2191static void addInstance(ClassDefMutable* classEntity, ClassDefMutable* ar,
2192 ClassDefMutable *cd , const std::shared_ptr<Entry> &cur)
2193{
2194
2195 QCString bName,n1;
2196 if (ar==nullptr) return;
2197
2198 if (classEntity==nullptr)
2199 {
2200 //add component inst
2201 n1=cur->type;
2202 goto ferr;
2203 }
2204
2205 if (classEntity==cd) return;
2206
2207 bName=classEntity->name();
2208 // fprintf(stderr,"\naddInstance %s to %s %s %s\n",qPrint( classEntity->name()),qPrint(cd->name()),qPrint(ar->name()),cur->name);
2209 n1=classEntity->name();
2210
2211 if (!cd->isBaseClass(classEntity, true))
2212 {
2213 cd->insertBaseClass(classEntity,n1,Protection::Public,Specifier::Normal,QCString());
2214 }
2215 else
2216 {
2217 VhdlDocGen::addBaseClass(cd,classEntity);
2218 }
2219
2220 if (!VhdlDocGen::isSubClass(classEntity,cd,true,0))
2221 {
2222 classEntity->insertSubClass(cd,Protection::Public,Specifier::Normal,QCString());
2223 classEntity->setLanguage(SrcLangExt::VHDL);
2224 }
2225
2226ferr:
2227 QCString uu=cur->name;
2228 auto md = createMemberDef(
2229 ar->getDefFileName(), cur->startLine,cur->startColumn,
2230 n1,uu,uu, QCString(),
2231 Protection::Public,
2232 Specifier::Normal,
2233 cur->isStatic,
2234 Relationship::Member,
2235 MemberType::Variable,
2236 ArgumentList(),
2237 ArgumentList(),
2238 "");
2239 auto mmd = toMemberDefMutable(md.get());
2240
2241 if (!ar->getOutputFileBase().isEmpty())
2242 {
2243 TagInfo tg;
2244 tg.anchor = nullptr;
2245 tg.fileName = ar->getOutputFileBase();
2246 tg.tagName = nullptr;
2247 mmd->setTagInfo(&tg);
2248 }
2249
2250 //fprintf(stderr,"\n%s%s%s\n",qPrint(md->name()),qPrint(cur->brief),qPrint(cur->doc));
2251
2252 mmd->setLanguage(SrcLangExt::VHDL);
2253 mmd->setVhdlSpecifiers(VhdlSpecifier::INSTANTIATION);
2254 mmd->setBriefDescription(cur->brief,cur->briefFile,cur->briefLine);
2255 mmd->setBodySegment(cur->startLine,cur->startLine,-1) ;
2256 mmd->setDocumentation(cur->doc,cur->docFile,cur->docLine);
2257 FileDef *fd=ar->getFileDef();
2258 mmd->setBodyDef(fd);
2259 ar->insertMember(md.get());
2260 MemberName *mn = Doxygen::functionNameLinkedMap->add(uu);
2261 mn->push_back(std::move(md));
2262
2263}

References VhdlDocGen::addBaseClass, TagInfo::anchor, createMemberDef, TagInfo::fileName, Doxygen::functionNameLinkedMap, Definition::getDefFileName, ClassDef::getFileDef, Definition::getOutputFileBase, ClassDefMutable::insertBaseClass, ClassDefMutable::insertMember, ClassDefMutable::insertSubClass, INSTANTIATION, ClassDef::isBaseClass, QCString::isEmpty, VhdlDocGen::isSubClass, Definition::name, MemberName::push_back, DefinitionMutable::setBodyDef, DefinitionMutable::setLanguage, TagInfo::tagName, toMemberDefMutable and Variable.

Referenced by VhdlDocGen::computeVhdlComponentRelations.

alignText()​

void alignText (QCString & q)

Definition at line 2553 of file vhdldocgen.cpp.

2553void alignText(QCString & q)
2554{
2555 if (q.length()<=80) return;
2556
2557 if (q.length()>200)
2558 {
2559 q.resize(200);
2560 }
2561
2562 q.append(" ...");
2563
2564 QCString str(q);
2565 QCString temp;
2566
2567 while (str.length()>80)
2568 {
2569 int j=std::max(str.findRev(' ',80),str.findRev('|',80));
2570 if (j<=0)
2571 {
2572 temp+=str;
2573 q=temp;
2574 return;
2575 }
2576 else
2577 {
2578 QCString qcs=str.left(j);
2579 temp+=qcs+"\\";
2580 temp+="n";
2581 str.remove(0,j);
2582 }
2583 }//while
2584
2585 q=temp+str;
2586// #endif
2587}

References QCString::append, QCString::findRev, QCString::left, QCString::length, QCString::remove and QCString::resize.

Referenced by FlowChart::writeShape.

compareString()​

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

Definition at line 117 of file vhdldocgen.cpp.

117static int compareString(const QCString& s1,const QCString& s2)
118{
119 return qstricmp(s1.stripWhiteSpace(),s2.stripWhiteSpace());
120}

References qstricmp and QCString::stripWhiteSpace.

Referenced by VhdlDocGen::findFunction.

findMemFlow()​

const MemberDef * findMemFlow (const MemberDef * mdef)
 static

Definition at line 2390 of file vhdldocgen.cpp.

2390static const MemberDef* findMemFlow(const MemberDef* mdef)
2391{
2392 for (const auto &md : mdList)
2393 {
2394 if (md->name()==mdef->name() && md->getStartBodyLine()==mdef->getStartBodyLine())
2395 {
2396 return md;
2397 }
2398 }
2399 return nullptr;
2400}

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

Referenced by VhdlDocGen::createFlowChart.

getSpecifierTypeFromClass()​

VhdlSpecifier getSpecifierTypeFromClass (const ClassDef * cd)
 static

Definition at line 414 of file vhdldocgen.cpp.

414static VhdlSpecifier getSpecifierTypeFromClass(const ClassDef *cd)
415{
416 VhdlDocGen::VhdlClasses ii=VhdlDocGen::convert(cd->protection());
417
418 QCString type;
419 if (ii==VhdlDocGen::ENTITYCLASS)
420 return VhdlSpecifier::ENTITY;
421 else if (ii==VhdlDocGen::ARCHITECTURECLASS)
422 return VhdlSpecifier::ARCHITECTURE;
423 else if (ii==VhdlDocGen::PACKBODYCLASS)
424 return VhdlSpecifier::PACKAGE_BODY;
425 else if (ii==VhdlDocGen::PACKAGECLASS)
426 return VhdlSpecifier::PACKAGE;
427 return VhdlSpecifier::UNKNOWN;
428}

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 QCString & type, QCString & qcs, int line, const QCString & fileName, QCString & brief)
 static

Definition at line 1977 of file vhdldocgen.cpp.

1977static void initUCF(Entry* root,const QCString &type,QCString &qcs,
1978 int line,const QCString &fileName,QCString & brief)
1979{
1980 if (qcs.isEmpty())return;
1981 QCString n;
1982
1983 VhdlDocGen::deleteAllChars(qcs,';');
1984 qcs=qcs.stripWhiteSpace();
1985
1986 static const reg::Ex reg(R"([\s=])");
1987 int i = findIndex(qcs.str(),reg);
1988 if (i<0) return;
1989 if (i==0)
1990 {
1991 n=type;
1992 VhdlDocGen::deleteAllChars(n,'#');
1993 }
1994 else
1995 {
1996 n=qcs.left(i);
1997 }
1998 qcs=qcs.remove(0,i+1);
1999 // qcs.prepend("|");
2000
2001 qcs.stripPrefix("=");
2002
2003 std::shared_ptr<Entry> current = std::make_shared<Entry>();
2004 current->vhdlSpec=VhdlSpecifier::UCF_CONST;
2005 current->section=EntryType::makeVariable();
2006 current->bodyLine=line;
2007 current->fileName=fileName;
2008 current->type="ucf_const";
2009 current->args+=qcs;
2010 current->lang= SrcLangExt::VHDL ;
2011
2012 // adding dummy name for constraints like VOLTAGE=5,TEMPERATURE=20 C
2013 if (n.isEmpty())
2014 {
2015 n="dummy";
2016 n+=VhdlDocGen::getRecordNumber();
2017 }
2018
2019 current->name= n+"_";
2020 current->name.append(VhdlDocGen::getRecordNumber());
2021
2022 if (!brief.isEmpty())
2023 {
2024 current->brief=brief;
2025 current->briefLine=line;
2026 current->briefFile=fileName;
2027 brief.clear();
2028 }
2029
2030 root->moveToSubEntryAndKeep(current);
2031}

References QCString::append, QCString::clear, VhdlDocGen::deleteAllChars, findIndex, VhdlDocGen::getRecordNumber, QCString::isEmpty, QCString::left, Entry::moveToSubEntryAndKeep, QCString::remove, QCString::str, QCString::stripPrefix, QCString::stripWhiteSpace and UCF_CONST.

Referenced by VhdlDocGen::parseUCF.

membersHaveSpecificType()​

bool membersHaveSpecificType (const MemberList * ml, VhdlSpecifier type)
 static

Definition at line 1725 of file vhdldocgen.cpp.

1725static bool membersHaveSpecificType(const MemberList *ml,VhdlSpecifier type)
1726{
1727 if (ml==nullptr) return FALSE;
1728 for (const auto &mdd : *ml)
1729 {
1730 if (mdd->getVhdlSpecifiers()==type) //is type in class
1731 {
1732 return TRUE;
1733 }
1734 }
1735 for (const auto &mg : ml->getMemberGroupList())
1736 {
1737 if (!mg->members().empty())
1738 {
1739 if (membersHaveSpecificType(&mg->members(),type)) return TRUE;
1740 }
1741 }
1742 return FALSE;
1743}

References FALSE, MemberList::getMemberGroupList, membersHaveSpecificType and TRUE.

Referenced by membersHaveSpecificType and VhdlDocGen::writeVHDLDeclarations.

splitString()​

QCString splitString (QCString & str, char c)
 static

Definition at line 105 of file vhdldocgen.cpp.

105static QCString splitString(QCString& str,char c)
106{
107 QCString n=str;
108 int i=str.find(c);
109 if (i>0)
110 {
111 n=str.left(i);
112 str=str.remove(0,i+1);
113 }
114 return n;
115}

References QCString::find, QCString::left and QCString::remove.

Referenced by writeUCFLink.

startFonts()​

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

Definition at line 97 of file vhdldocgen.cpp.

97static void startFonts(const QCString& q, const char *keyword,OutputList& ol)
98{
99 auto &codeOL = ol.codeGenerators();
100 codeOL.startFontClass(keyword);
101 codeOL.codify(q);
102 codeOL.endFontClass();
103}

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 89 of file vhdldocgen.cpp.

89static void writeLink(const MemberDef* mdef,OutputList &ol)
90{
91 ol.writeObjectLink(mdef->getReference(),
92 mdef->getOutputFileBase(),
93 mdef->anchor(),
94 mdef->name());
95}

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 2034 of file vhdldocgen.cpp.

2034static void writeUCFLink(const MemberDef* mdef,OutputList &ol)
2035{
2036
2037 QCString largs(mdef->argsString());
2038 QCString n= splitString(largs, '#');
2039 // VhdlDocGen::adjustRecordMember(mdef);
2040 bool equ=(n.length()==largs.length());
2041
2042 if (!equ)
2043 {
2044 ol.writeString(n);
2045 ol.docify(" ");
2046 ol.insertMemberAlign();
2047 }
2048
2049 if (mdef->name().contains("dummy")==0)
2050 {
2051 writeLink(mdef,ol);
2052 }
2053 if (equ)
2054 {
2055 ol.insertMemberAlign();
2056 }
2057 ol.docify(" ");
2058 VhdlDocGen::formatString(largs,ol,mdef);
2059}

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

Referenced by VhdlDocGen::writeVHDLDeclaration.

Variables​

comment​

const char* comment

Definition at line 2531 of file vhdldocgen.cpp.

2531 const char* comment;

Referenced by codifyLines, CommentScanner::parseCommentBlock, VhdlDocGen::parseUCF and writeObjCMethodCall.

decisionNode​

const char* decisionNode

Definition at line 2532 of file vhdldocgen.cpp.

2532 const char* decisionNode;

flowCol​

struct flowCol
 static
Initialiser
= { "green", "red", "black", "khaki", "0.7 0.3 1.0", "lightyellow", "white", "lightcyan" }

Definition at line 2545 of file vhdldocgen.cpp.

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

flowList​

std::vector<FlowChart> flowList

Definition at line 2547 of file vhdldocgen.cpp.

2547std::vector<FlowChart> flowList;

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 75 of file vhdldocgen.cpp.

75static const MemberDef *flowMember=nullptr;

Referenced by VhdlDocGen::getFlowMember, VhdlDocGen::setFlowMember and VhdlDocGen::writeRecordProto.

g_classList​

std::vector<ClassDef*> g_classList
 static

Definition at line 214 of file vhdldocgen.cpp.

214static std::vector<ClassDef*> g_classList;

Referenced by VhdlDocGen::findMemberDef and VhdlDocGen::resetCodeVhdlParserState.

g_packages​

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

Definition at line 215 of file vhdldocgen.cpp.

215static std::map<ClassDef*,std::vector<ClassDef*> > g_packages;

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

g_varMap​

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

Definition at line 213 of file vhdldocgen.cpp.

213static std::map<std::string,const MemberDef*> g_varMap;

Referenced by VhdlDocGen::findMemberDef and VhdlDocGen::resetCodeVhdlParserState.

g_vhdlKeyWordSet0​

const std::unordered_set< std::string > g_vhdlKeyWordSet0
 static
Initialiser
= { "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 125 of file vhdldocgen.cpp.

125static const std::unordered_set< std::string > g_vhdlKeyWordSet0 =
126{
127 "abs","access","after","alias","all","and","architecture","array","assert","assume","assume_guarantee","attribute",
128 "begin","block","body","buffer","bus",
129 "case","component","configuration","constant","context","cover",
130 "default","disconnect","downto",
131 "else","elsif","end","entity","exit",
132 "fairness","file","for","force","function",
133 "generate","generic","group","guarded",
134 "if","impure","in","inertial","inout","is",
135 "label","library","linkage","literal","loop",
136 "map","mod",
137 "nand","new","next","nor","not","null",
138 "of","on","open","or","others","out",
139 "package","parameter","port","postponed","procedure","process","property","protected","pure",
140 "range","record","register","reject","release","restrict","restrict_guarantee","rem","report","rol","ror","return",
141 "select","sequence","severity","signal","shared","sla","sll","sra","srl","strong","subtype",
142 "then","to","transport","type",
143 "unaffected","units","until","use",
144 "variable","vmode","vprop","vunit",
145 "wait","when","while","with",
146 "xor","xnor"
147};

Referenced by VhdlDocGen::findKeyWord.

g_vhdlKeyWordSet1​

const std::unordered_set< std::string> g_vhdlKeyWordSet1
 static
Initialiser
= { "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 151 of file vhdldocgen.cpp.

151static const std::unordered_set< std::string> g_vhdlKeyWordSet1 =
152{
153 "natural","unsigned","signed","string","boolean", "bit","bit_vector","character",
154 "std_ulogic","std_ulogic_vector","std_logic","std_logic_vector","integer",
155 "real","float","ufixed","sfixed","time","positive"
156};

Referenced by VhdlDocGen::findKeyWord.

g_vhdlKeyWordSet2​

const std::unordered_set< std::string > g_vhdlKeyWordSet2
 static
Initialiser
= { "abs","and","or","not","mod","xor","rem","xnor","ror","rol","sla","sll" }

Definition at line 159 of file vhdldocgen.cpp.

159static const std::unordered_set< std::string > g_vhdlKeyWordSet2 =
160{
161 "abs","and","or","not","mod","xor","rem","xnor","ror","rol","sla","sll"
162};

Referenced by VhdlDocGen::findKeyWord.

g_vhdlKeyWordSet3​

const std::unordered_set< std::string > g_vhdlKeyWordSet3
 static
Initialiser
= { "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 165 of file vhdldocgen.cpp.

165static const std::unordered_set< std::string > g_vhdlKeyWordSet3 =
166{
167 "base","left","right","high","low","ascending",
168 "image","value","pos","val","succ","pred","leftof","rightof","left","right","high","low",
169 "range","reverse_range","length","ascending","delayed","stable","quiet","transaction","event",
170 "active","last_event","last_active","last_value","driving","driving_value","simple_name","instance_name","path_name"
171};

Referenced by VhdlDocGen::findKeyWord.

g_vhdlMutex​

std::recursive_mutex g_vhdlMutex
 static

Definition at line 212 of file vhdldocgen.cpp.

212static std::recursive_mutex g_vhdlMutex;

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

ifcounter​

int ifcounter =0
 static

Definition at line 2520 of file vhdldocgen.cpp.

2520static int ifcounter=0;

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

mdList​

std::vector<const MemberDef*> mdList
 static

Definition at line 2388 of file vhdldocgen.cpp.

2388static std::vector<const MemberDef*> mdList;

Referenced by VhdlDocGen::createFlowChart and findMemFlow.

nodeCounter​

int nodeCounter =0
 static

Definition at line 2521 of file vhdldocgen.cpp.

2521static int nodeCounter=0;

Referenced by FlowChart::delFlowList and FlowChart::FlowChart.

noNodeLink​

const char* noNodeLink

Definition at line 2528 of file vhdldocgen.cpp.

2528 const char *noNodeLink;

recordCounter​

int recordCounter =0
 static

Definition at line 738 of file vhdldocgen.cpp.

738static int recordCounter=0;

Referenced by VhdlDocGen::getRecordNumber.

startEndNode​

const char* startEndNode

Definition at line 2534 of file vhdldocgen.cpp.

2534 const char *startEndNode;

textNode​

const char* textNode

Definition at line 2535 of file vhdldocgen.cpp.

2535 const char* textNode;

textNodeLink​

const char* textNodeLink

Definition at line 2526 of file vhdldocgen.cpp.

2526 const char *textNodeLink;

varNode​

const char* varNode

Definition at line 2533 of file vhdldocgen.cpp.

2533 const char* varNode;

yesNodeLink​

const char* yesNodeLink

Definition at line 2527 of file vhdldocgen.cpp.

2527 const char *yesNodeLink;

Macro Definitions​

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 2504 of file vhdldocgen.cpp.

2504#define DECLN (FlowChart::WHEN_NO | \
2505 FlowChart::ELSIF_NO | FlowChart::IF_NO | \
2506 FlowChart::FOR_NO | FlowChart::WHILE_NO | \
2507 FlowChart::CASE_NO | FlowChart::LOOP_NO )

Referenced by FlowChart::writeShape.

EE​

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

Definition at line 2516 of file vhdldocgen.cpp.

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

EEND​

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

Definition at line 2512 of file vhdldocgen.cpp.

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

Referenced by FlowChart::writeFlowLinks and FlowChart::writeShape.

EMPTNODE​

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

Definition at line 2517 of file vhdldocgen.cpp.

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

Referenced by FlowChart::printNode.

EMPTY​

#define EMPTY   (EEND | FlowChart::ELSIF_NO)

Definition at line 2515 of file vhdldocgen.cpp.

2515#define EMPTY (EEND | FlowChart::ELSIF_NO)

Referenced by FlowChart::colTextNodes.

ENDCL​

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

Definition at line 2511 of file vhdldocgen.cpp.

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

Referenced by FlowChart::writeShape.

EXITNEXT​

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

Definition at line 2514 of file vhdldocgen.cpp.

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

Referenced by FlowChart::writeShape.

FLOWLEN​

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

Definition at line 2518 of file vhdldocgen.cpp.

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

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

IFF​

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

Definition at line 2513 of file vhdldocgen.cpp.

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

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 2509 of file vhdldocgen.cpp.

2509#define LOOP (FlowChart::FOR_NO | FlowChart::WHILE_NO | \
2510 FlowChart::LOOP_NO )

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

STARTFIN​

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

Definition at line 2508 of file vhdldocgen.cpp.

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

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 2501 of file vhdldocgen.cpp.

2501#define STARTL (FlowChart::WHILE_NO | FlowChart::IF_NO | \
2502 FlowChart::FOR_NO | FlowChart::CASE_NO | \
2503 FlowChart::LOOP_NO | WHEN_NO)

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

theTranslator_vhdlType​

#define theTranslator_vhdlType   theTranslator->trVhdlType

Definition at line 68 of file vhdldocgen.cpp.

68#define theTranslator_vhdlType theTranslator->trVhdlType

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

Generated via doxygen2docusaurus by Doxygen 1.14.0.