vhdldocgen.cpp File Reference

#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"

Include dependency graph for vhdldocgen.cpp:

Go to the source code of this file.

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 QCString &type, QCString &qcs, int line, const QCString &fileName, QCString &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 QCString &q, const char *keyword, OutputList &ol)
static QCString	splitString (QCString &str, char c)
static int	compareString (const QCString &s1, const QCString &s2)
static VhdlSpecifier	getSpecifierTypeFromClass (const ClassDef *cd)
static bool	membersHaveSpecificType (const MemberList *ml, VhdlSpecifier type)
static const MemberDef *	findMemFlow (const MemberDef *mdef)
void	alignText (QCString &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
struct {
const char *   textNodeLink
const char *   yesNodeLink
const char *   noNodeLink
const char *   comment
const char *   decisionNode
const char *   varNode
const char *   startEndNode
const char *   textNode
}	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 2512 of file vhdldocgen.cpp.

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

Referenced by FlowChart::writeShape().

EE

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

Definition at line 2524 of file vhdldocgen.cpp.

EEND

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

Definition at line 2520 of file vhdldocgen.cpp.

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

EMPTNODE

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

Definition at line 2525 of file vhdldocgen.cpp.

Referenced by FlowChart::printNode().

EMPTY

#define EMPTY   (EEND | FlowChart::ELSIF_NO)

Definition at line 2523 of file vhdldocgen.cpp.

Referenced by FlowChart::colTextNodes().

ENDCL

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

Definition at line 2519 of file vhdldocgen.cpp.

Referenced by FlowChart::writeShape().

EXITNEXT

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

Definition at line 2522 of file vhdldocgen.cpp.

Referenced by FlowChart::writeShape().

FLOWLEN

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

Definition at line 2526 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 2521 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 2517 of file vhdldocgen.cpp.

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

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

STARTFIN

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

Definition at line 2516 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 2509 of file vhdldocgen.cpp.

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

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

theTranslator_vhdlType

#define theTranslator_vhdlType   theTranslator->trVhdlType

Definition at line 66 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 2199 of file vhdldocgen.cpp.

{
 
  QCString 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,QCString());
  }
  else
  {
    VhdlDocGen::addBaseClass(cd,classEntity);
  }
 
  if (!VhdlDocGen::isSubClass(classEntity,cd,true,0))
  {
    classEntity->insertSubClass(cd,Protection::Public,Specifier::Normal,QCString());
    classEntity->setLanguage(SrcLangExt::VHDL);
  }
 
ferr:
  QCString uu=cur->name;
  auto md = createMemberDef(
      ar->getDefFileName(), cur->startLine,cur->startColumn,
      n1,uu,uu, QCString(),
      Protection::Public,
      Specifier::Normal,
      cur->isStatic,
      Relationship::Member,
      MemberType::Variable,
      ArgumentList(),
      ArgumentList(),
      "");
  auto mmd = toMemberDefMutable(md.get());
 
  if (!ar->getOutputFileBase().isEmpty())
  {
    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 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 2561 of file vhdldocgen.cpp.

{
  if (q.length()<=80) return;
 
  if (q.length()>200)
  {
    q.resize(200);
  }
 
  q.append(" ...");
 
  QCString str(q);
  QCString temp;
 
  while (str.length()>80)
  {
    int j=std::max(str.findRev(' ',80),str.findRev('|',80));
    if (j<=0)
    {
      temp+=str;
      q=temp;
      return;
    }
    else
    {
      QCString qcs=str.left(j);
      temp+=qcs+"\\";
      temp+="n";
      str.remove(0,j);
    }
  }//while
 
 q=temp+str;
// #endif
}

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

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

References qstricmp(), and QCString::stripWhiteSpace().

Referenced by VhdlDocGen::findFunction().

findMemFlow()

const MemberDef * findMemFlow ( const MemberDef * mdef )

static

Definition at line 2398 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 412 of file vhdldocgen.cpp.

{
  VhdlDocGen::VhdlClasses ii=VhdlDocGen::convert(cd->protection());
 
  QCString 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 QCString & type, QCString & qcs, int line, const QCString & fileName, QCString & brief )

static

Definition at line 1985 of file vhdldocgen.cpp.

{
  if (qcs.isEmpty())return;
  QCString n;
 
  VhdlDocGen::deleteAllChars(qcs,';');
  qcs=qcs.stripWhiteSpace();
 
  static const reg::Ex reg(R"([\s=])");
  int i = findIndex(qcs.str(),reg);
  if (i<0) 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.isEmpty())
  {
    n="dummy";
    n+=VhdlDocGen::getRecordNumber();
  }
 
  current->name= n+"_";
  current->name.append(VhdlDocGen::getRecordNumber());
 
  if (!brief.isEmpty())
  {
    current->brief=brief;
    current->briefLine=line;
    current->briefFile=fileName;
    brief.clear();
  }
 
  root->moveToSubEntryAndKeep(current);
}

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 1726 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 FALSE, MemberList::getMemberGroupList(), membersHaveSpecificType(), and TRUE.

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

splitString()

QCString splitString ( QCString & str, char c )

static

Definition at line 103 of file vhdldocgen.cpp.

{
  QCString n=str;
  int i=str.find(c);
  if (i>0)
  {
    n=str.left(i);
    str=str.remove(0,i+1);
  }
  return n;
}

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 95 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 87 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 2042 of file vhdldocgen.cpp.

{
 
  QCString largs(mdef->argsString());
  QCString 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(), QCString::contains(), OutputList::docify(), VhdlDocGen::formatString(), OutputList::insertMemberAlign(), QCString::length(), Definition::name(), splitString(), writeLink(), and OutputList::writeString().

Referenced by VhdlDocGen::writeVHDLDeclaration().

Variable Documentation

comment

const char* comment

Definition at line 2539 of file vhdldocgen.cpp.

Referenced by codifyLines(), CommentScanner::parseCommentBlock(), and VhdlDocGen::parseUCF().

decisionNode

const char* decisionNode

Definition at line 2540 of file vhdldocgen.cpp.

[struct]

struct { ... } 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 2555 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 73 of file vhdldocgen.cpp.

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

g_classList

std::vector<ClassDef*> g_classList

static

Definition at line 212 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 213 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 211 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 123 of file vhdldocgen.cpp.

                                                             {
  "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"
};

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

                                                            {
  "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"
};

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

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

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

                                                             {
  "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"
};

Referenced by VhdlDocGen::findKeyWord().

g_vhdlMutex

std::recursive_mutex g_vhdlMutex

static

Definition at line 210 of file vhdldocgen.cpp.

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

ifcounter

int ifcounter =0

static

Definition at line 2528 of file vhdldocgen.cpp.

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

mdList

std::vector<const MemberDef*> mdList

static

Definition at line 2396 of file vhdldocgen.cpp.

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

nodeCounter

int nodeCounter =0

static

Definition at line 2529 of file vhdldocgen.cpp.

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

noNodeLink

const char* noNodeLink

Definition at line 2536 of file vhdldocgen.cpp.

recordCounter

int recordCounter =0

static

Definition at line 735 of file vhdldocgen.cpp.

Referenced by VhdlDocGen::getRecordNumber().

startEndNode

const char* startEndNode

Definition at line 2542 of file vhdldocgen.cpp.

textNode

const char* textNode

Definition at line 2543 of file vhdldocgen.cpp.

textNodeLink

const char* textNodeLink

Definition at line 2534 of file vhdldocgen.cpp.

varNode

const char* varNode

Definition at line 2541 of file vhdldocgen.cpp.

yesNodeLink

const char* yesNodeLink

Definition at line 2535 of file vhdldocgen.cpp.