VHDLOutlineParser Class Reference

VHDL parser using state-based lexical scanning. More...

#include <src/vhdljjparser.h>

Inheritance diagram for VHDLOutlineParser:

Collaboration diagram for VHDLOutlineParser:

Classes
struct	Private

Public Member Functions
	VHDLOutlineParser ()
	~VHDLOutlineParser () override
void	parseInput (const DString &fileName, const char *fileBuf, const std::shared_ptr< Entry > &root, ClangTUParser *clangParser) override
	Parses a single input file with the goal to build an Entry tree.
bool	needsPreprocessing (const DString &) const override
	Returns true if the language identified by extension needs the C preprocessor to be run before feed the result to the input parser.
void	parsePrototype (const DString &text) override
	Callback function called by the comment block scanner.
void	setLineParsed (int tok)
int	getLine (int tok)
int	getLine ()
void	lineCount (const DString &)
void	lineCount ()
void	addProto (const DString &s1, const DString &s2, const DString &s3, const DString &s4, const DString &s5, const DString &s6)
void	createFunction (const DString &impure, VhdlSpecifier spec, const DString &fname)
void	addVhdlType (const DString &n, int startLine, EntryType section, VhdlSpecifier spec, const DString &args, const DString &type, Protection prot)
void	addCompInst (const DString &n, const DString &instName, const DString &comp, int iLine)
void	handleCommentBlock (const DString &doc, bool brief)
void	handleFlowComment (const DString &)
void	initEntry (Entry *e)
void	newEntry ()
bool	isFuncProcProced ()
void	pushLabel (DString &, DString &)
DString	popLabel (DString &q)
bool	addLibUseClause (const DString &type)
void	mapLibPackage (Entry *root)
void	createFlow ()
void	error_skipto (int kind)
void	oneLineComment (DString qcs)
void	setMultCommentLine ()
bool	checkMultiComment (DString &qcs, int line)
void	insertEntryAtLine (std::shared_ptr< Entry > ce, int line)
DString	getNameID ()
	returns a unique id for each record member.
size_t	checkInlineCode (DString &doc)

Private Attributes
std::unique_ptr< Private >	p

Detailed Description

VHDL parser using state-based lexical scanning.

This is the VHDL language parser for doxygen.

Definition at line 19 of file vhdljjparser.h.

Constructor & Destructor Documentation

VHDLOutlineParser()

VHDLOutlineParser::VHDLOutlineParser

(

)

Definition at line 123 of file vhdljjparser.cpp.

                                     : p(std::make_unique<Private>())
{
}

References p.

~VHDLOutlineParser()

VHDLOutlineParser::~VHDLOutlineParser ( )

override

Definition at line 127 of file vhdljjparser.cpp.

{
}

Member Function Documentation

addCompInst()

void VHDLOutlineParser::addCompInst	(	const DString &	n,
		const DString &	instName,
		const DString &	comp,
		int	iLine )

Definition at line 477 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  s->current->vhdlSpec=VhdlSpecifier::INSTANTIATION;
  s->current->section=EntryType::makeVariable();
  s->current->startLine=iLine;
  s->current->bodyLine=iLine;
  s->current->type=instName;                       // foo:instname e.g proto or work. proto(ttt)
  s->current->exception=s->genLabels.lower();         // |arch|label1:label2...
  s->current->name=n;                              // foo
  if (s->lastCompound)
  {
    s->current->args=s->lastCompound->name;             // architecture name
  }
  s->current->includeName=comp;                    // component/entity/configuration
  size_t u=s->genLabels.find('|',1);
  if (u!=DString::npos && u>0)
  {
    s->current->write=s->genLabels.mid(u);
    s->current->read=s->genLabels.left(u);
  }
  //printf  (" \n genlabel: [%s]  inst: [%s]  name: [%s] %d\n",n,instName,comp,iLine);
 
  if (s->lastCompound)
  {
    s->current->args=s->lastCompound->name;
    if (true) // !findInstant(current->type))
    {
      initEntry(s->current.get());
      // TODO: protect with mutex
      g_instFiles.emplace_back(std::make_shared<Entry>(*s->current));
      // TODO: end protect with mutex
    }
 
    s->current=std::make_shared<Entry>();
  }
  else
  {
    newEntry();
  }
}

References vhdl::parser::VhdlParser::SharedState::current, DString::find(), g_instFiles, vhdl::parser::VhdlParser::SharedState::genLabels, initEntry(), INSTANTIATION, vhdl::parser::VhdlParser::SharedState::lastCompound, DString::left(), DString::lower(), DString::mid(), newEntry(), DString::npos, and p.

addLibUseClause()

bool VHDLOutlineParser::addLibUseClause

(

const DString &

type

)

Definition at line 709 of file vhdljjparser.cpp.

{
  bool showIEEESTD=Config_getBool(FORCE_LOCAL_INCLUDES);
 
  if (showIEEESTD) // all standard packages and libraries will not be shown
  {
    if (type.lower().stripPrefix("ieee")) return false;
    if (type.lower().stripPrefix("std")) return false;
  }
  return true;
}

References Config_getBool, DString::lower(), and DString::stripPrefix().

Referenced by mapLibPackage().

addProto()

void VHDLOutlineParser::addProto	(	const DString &	s1,
		const DString &	s2,
		const DString &	s3,
		const DString &	s4,
		const DString &	s5,
		const DString &	s6 )

Definition at line 631 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  StringVector ql=split(s2.str(),",");
 
  for (const auto &n : ql)
  {
    Argument arg;
    arg.name=n;
    if (!s3.empty())
    {
      arg.type=s3;
    }
    arg.type+=" ";
    arg.type+=s4;
    if (!s6.empty())
    {
      arg.type+=s6;
    }
    if (s->parse_sec==VhdlSection::GEN_SEC && s->param_sec==VhdlSection::UNKNOWN)
    {
      arg.defval="generic";
    }
 
    if (s->parse_sec==VhdlSection::PARAM_SEC)
    {
    //  assert(false);
    }
 
    arg.defval+=s1;
    arg.attrib="";//s6;
 
    s->current->argList.push_back(arg);
    s->current->args+=s2;
    s->current->args+=",";
  }
}

References Argument::attrib, vhdl::parser::VhdlParser::SharedState::current, Argument::defval, DString::empty(), GEN_SEC, Argument::name, p, PARAM_SEC, vhdl::parser::VhdlParser::SharedState::param_sec, vhdl::parser::VhdlParser::SharedState::parse_sec, split(), DString::str(), Argument::type, and UNKNOWN.

addVhdlType()

void VHDLOutlineParser::addVhdlType	(	const DString &	n,
		int	startLine,
		EntryType	section,
		VhdlSpecifier	spec,
		const DString &	args,
		const DString &	type,
		Protection	prot )

Definition at line 519 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  if (isFuncProcProced() || VhdlDocGen::getFlowMember())  return;
 
  if (s->parse_sec==VhdlSection::GEN_SEC)
  {
    spec=VhdlSpecifier::GENERIC;
  }
 
  StringVector ql=split(n.str(),",");
 
  for (size_t u=0;u<ql.size();u++)
  {
    s->current->name=ql[u];
    s->current->startLine=startLine;
    s->current->bodyLine=startLine;
    s->current->section=section;
    s->current->vhdlSpec=spec;
    s->current->fileName=p->yyFileName;
    if (s->current->args.empty())
    {
      s->current->args=args;
    }
    s->current->type=type;
    s->current->protection=prot;
 
    if (!s->lastCompound && section.isVariable() &&  (spec == VhdlSpecifier::USE || spec == VhdlSpecifier::LIBRARY) )
    {
      p->libUse.emplace_back(std::make_shared<Entry>(*s->current));
      s->current->reset();
    }
    newEntry();
  }
}

References vhdl::parser::VhdlParser::SharedState::current, GEN_SEC, GENERIC, VhdlDocGen::getFlowMember(), isFuncProcProced(), vhdl::parser::VhdlParser::SharedState::lastCompound, LIBRARY, newEntry(), p, vhdl::parser::VhdlParser::SharedState::parse_sec, split(), DString::str(), and USE.

checkInlineCode()

size_t VHDLOutlineParser::checkInlineCode

(

DString &

doc

)

Definition at line 276 of file vhdljjparser.cpp.

{
  static const reg::Ex csRe(R"([\\@]code)");
  static const reg::Ex cendRe(R"(\s*[\\@]endcode)");
  static const reg::Ex cbriefRe(R"([\\@]brief)");
 
  // helper to simulate behavior of QString.find(const QRegExp &re,int pos)
  auto findRe = [](const DString &str,const reg::Ex &re,size_t pos=0) -> size_t
  {
    if (str.length()<pos) return DString::npos;
    reg::Match match;
    if (reg::search(str.str(),match,re,pos)) // match found
    {
      return match.position();
    }
    else // not found
    {
      return DString::npos;
    }
  };
  auto replaceRe = [](const DString &str,const reg::Ex &re,const DString &replacement) -> DString
  {
    return reg::replace(str.str(), re, replacement.str());
  };
 
  size_t index = findRe(doc,csRe);
 
  if (findRe(doc,cendRe)!=DString::npos)
    return 1;
 
  if (index==DString::npos)
    return index;
 
  VhdlParser::SharedState *s = &p->shared;
  p->strComment += doc;
  p->code = findRe(p->inputString,csRe, p->code + 1);
  size_t com = p->inputString.find(p->strComment);
  size_t ref = findRe(p->inputString,cendRe, p->code + 1);
  size_t len = p->strComment.size();
 
  size_t ll = com + len;
  int diff = static_cast<int>(ref) - static_cast<int>(ll) - 3;
  DString code = p->inputString.mid(ll, diff);
  int iLine = 0;
  code = stripLeadingAndTrailingEmptyLines(code, iLine);
  int val = code.contains('\n');
  VhdlDocGen::prepareComment(p->strComment);
  StringVector ql = split(p->strComment.str(),"\n");
 
  DString co;
  DString na;
  for (const auto &qcs_ : ql)
  {
    DString qcs(qcs_);
    qcs = qcs.simplifyWhiteSpace();
    if (findRe(qcs,csRe)!=DString::npos)
    {
      size_t i = qcs.find('{');
      size_t j = qcs.find('}');
      if (i!=DString::npos && j!=DString::npos && i>0 && j > i)
      {
        na = qcs.mid(i+1, j-i-1);
      }
      continue;
    }
    qcs = replaceRe(qcs,cbriefRe, "");
    co += qcs;
    co += '\n';
  }
 
  VhdlDocGen::prepareComment(co);
 
  Entry gBlock;
  if (!na.empty())
    gBlock.name = na;
  else
    gBlock.name = "misc" + VhdlDocGen::getRecordNumber();
  gBlock.startLine = p->yyLineNr+iLine-1;
  gBlock.bodyLine = p->yyLineNr+iLine-1 ;
  gBlock.doc = code;
  gBlock.inbodyDocs = code;
  gBlock.brief = co;
  gBlock.section = EntryType::makeVariable();
  gBlock.vhdlSpec = VhdlSpecifier::MISCELLANEOUS;
  gBlock.fileName = p->yyFileName;
  gBlock.endBodyLine = p->yyLineNr + val +iLine;
  gBlock.lang = SrcLangExt::VHDL;
  std::shared_ptr<Entry> compound;
 
  if (s->lastEntity)
    compound = s->lastEntity;
  else if (s->lastCompound)
    compound = s->lastCompound;
  else
    compound = nullptr;
 
  if (compound)
  {
    compound->copyToSubEntry(&gBlock);
  }
  else
  {
    gBlock.type = "misc"; // global code like library ieee...
    s->current_root->copyToSubEntry(&gBlock);
  }
  p->strComment.clear();
  return 1;
}

References Entry::bodyLine, Entry::brief, DString::contains(), vhdl::parser::VhdlParser::SharedState::current_root, Entry::doc, DString::empty(), Entry::endBodyLine, Entry::fileName, DString::find(), VhdlDocGen::getRecordNumber(), Entry::inbodyDocs, Entry::lang, vhdl::parser::VhdlParser::SharedState::lastCompound, vhdl::parser::VhdlParser::SharedState::lastEntity, DString::length(), DString::mid(), MISCELLANEOUS, Entry::name, DString::npos, p, VhdlDocGen::prepareComment(), reg::replace(), reg::search(), Entry::section, DString::simplifyWhiteSpace(), split(), Entry::startLine, DString::str(), stripLeadingAndTrailingEmptyLines(), Entry::type, and Entry::vhdlSpec.

Referenced by handleCommentBlock().

checkMultiComment()

bool VHDLOutlineParser::checkMultiComment	(	DString &	qcs,
		int	line )

Definition at line 806 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  insertEntryAtLine(s->current_root,line);
 
  if (p->lineEntry.empty()) return false;
 
  VhdlDocGen::prepareComment(qcs);
  while (!p->lineEntry.empty())
  {
    std::shared_ptr<Entry> e=p->lineEntry.back();
    e->briefLine=line;
    e->brief+=qcs;
 
    p->lineEntry.pop_back();
  }
  return true;
}

References vhdl::parser::VhdlParser::SharedState::current_root, insertEntryAtLine(), p, and VhdlDocGen::prepareComment().

Referenced by handleCommentBlock(), and oneLineComment().

createFlow()

void VHDLOutlineParser::createFlow

(

)

Definition at line 741 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  if (!VhdlDocGen::getFlowMember())
  {
    return;
  }
  DString q,ret;
 
  if (s->currP==VhdlSpecifier::FUNCTION)
  {
    q=":function( ";
    FlowChart::alignFuncProc(q,s->tempEntry->argList,true);
    q+=")";
  }
  else if (s->currP==VhdlSpecifier::PROCEDURE)
  {
    q=":procedure (";
    FlowChart::alignFuncProc(q,s->tempEntry->argList,false);
    q+=")";
  }
  else
  {
    q=":process( "+s->tempEntry->args;
    q+=")";
  }
 
  q.prepend(VhdlDocGen::getFlowMember()->name());
 
  FlowChart::addFlowChart(FlowChart::START_NO,q,DString());
 
  if (s->currP==VhdlSpecifier::FUNCTION)
  {
    ret="end function ";
  }
  else if (s->currP==VhdlSpecifier::PROCEDURE)
  {
    ret="end procedure";
  }
  else
  {
    ret="end process ";
  }
 
  FlowChart::addFlowChart(FlowChart::END_NO,ret,DString());
  //  FlowChart::printFlowList();
  FlowChart::writeFlowChart();
  s->currP=VhdlSpecifier::UNKNOWN;
}

References FlowChart::addFlowChart(), FlowChart::alignFuncProc(), vhdl::parser::VhdlParser::SharedState::currP, DString::DString(), FlowChart::END_NO, FUNCTION, VhdlDocGen::getFlowMember(), p, DString::prepend(), PROCEDURE, FlowChart::START_NO, vhdl::parser::VhdlParser::SharedState::tempEntry, UNKNOWN, and FlowChart::writeFlowChart().

createFunction()

void VHDLOutlineParser::createFunction	(	const DString &	impure,
		VhdlSpecifier	spec,
		const DString &	fname )

Definition at line 556 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  s->current->vhdlSpec=spec;
  s->current->section=EntryType::makeFunction();
 
  if (impure=="impure" || impure=="pure")
  {
    s->current->exception=impure;
  }
 
  if (s->parse_sec==VhdlSection::GEN_SEC)
  {
    s->current->vhdlSpec=VhdlSpecifier::GENERIC;
    s->current->section=EntryType::makeFunction();
  }
 
  if (s->currP==VhdlSpecifier::PROCEDURE)
  {
    s->current->name=impure;
    s->current->exception="";
  }
  else
  {
    s->current->name=fname;
  }
 
  if (spec==VhdlSpecifier::PROCESS)
  {
    s->current->args=fname;
    s->current->name=impure;
    VhdlDocGen::deleteAllChars(s->current->args,' ');
    if (!fname.empty())
    {
      StringVector q1=split(fname.str(),",");
      for (const auto &name : q1)
      {
        Argument arg;
        arg.name=name;
        s->current->argList.push_back(arg);
      }
    }
  }
}

References vhdl::parser::VhdlParser::SharedState::current, vhdl::parser::VhdlParser::SharedState::currP, VhdlDocGen::deleteAllChars(), DString::empty(), GEN_SEC, GENERIC, Argument::name, p, vhdl::parser::VhdlParser::SharedState::parse_sec, PROCEDURE, PROCESS, split(), and DString::str().

error_skipto()

void VHDLOutlineParser::error_skipto

(

int

kind

)

Definition at line 844 of file vhdljjparser.cpp.

{
  Token *op;
  do
  {
    p->vhdlParser->getNextToken();  // step to next token
    op=p->vhdlParser->getToken(1);  // get first token
    if (op==nullptr) break;
    //fprintf(stderr,"\n %s",qPrint(t->image));
  } while (op->kind != kind);
  p->vhdlParser->clearError();
  // The above loop consumes tokens all the way up to a token of
  // "kind".  We use a do-while loop rather than a while because the
  // current token is the one immediately before the erroneous token
  // (in our case the token immediately before what should have been
  // "if"/"while".
}

References vhdl::parser::Token::kind, and p.

getLine() [1/2]

int VHDLOutlineParser::getLine

(

)

Definition at line 721 of file vhdljjparser.cpp.

{
  return p->yyLineNr;
}

References p.

getLine() [2/2]

int VHDLOutlineParser::getLine

(

int

tok

)

Definition at line 732 of file vhdljjparser.cpp.

{
  int val=p->lineParse[tok];
  if (val<0) val=0;
  //assert(val>=0 && val<=yyLineNr);
  return val;
}

References p.

getNameID()

DString VHDLOutlineParser::getNameID

(

)

returns a unique id for each record member.

type first_rec is record RE: data_type; end;

type second_rec is record RE: data_type; end;

Definition at line 258 of file vhdljjparser.cpp.

{
  return DString().setNum(idCounter++);
}

References DString::DString(), idCounter, and DString::setNum().

handleCommentBlock()

void VHDLOutlineParser::handleCommentBlock	(	const DString &	doc,
		bool	brief )

Definition at line 385 of file vhdljjparser.cpp.

{
  int position = 0;
  bool needsEntry = false;
  VhdlParser::SharedState *s = &p->shared;
  DString doc = doc1;
 
  if (doc.empty())
    return;
 
  if (checkMultiComment(doc, p->yyLineNr))
  {
    p->strComment.clear();
    return;
  }
 
  if (checkInlineCode(doc) != DString::npos)
  {
    return;
  }
 
  Protection protection = Protection::Public;
  VhdlDocGen::prepareComment(doc);
  if (doc.empty()) return;
 
  if (p->oldEntry == s->current.get())
  {
    p->str_doc.doc = doc;
    p->str_doc.iDocLine = p->iDocLine;
    p->str_doc.brief = brief;
    p->str_doc.pending = true;
    return;
  }
 
  p->oldEntry = s->current.get();
 
  if (brief)
  {
    s->current->briefLine = p->yyLineNr;
  }
  else
  {
    s->current->docLine = p->yyLineNr;
  }
 
 
 
  Markdown markdown(p->yyFileName,p->iDocLine);
  int lineNr = p->iDocLine;
  GuardedSectionStack guards;
  DString processedDoc = Config_getBool(MARKDOWN_SUPPORT) ? markdown.process(doc,lineNr) : doc;
 
   while (p->commentScanner.parseCommentBlock(
      p->thisParser,
      s->current.get(),
      processedDoc,  // text
      p->yyFileName, // file
      lineNr,       // line of block start
      brief,
      0,
      false,
      protection,
      position,
      needsEntry,
      Config_getBool(MARKDOWN_SUPPORT),
      &guards
    ))
  {
    if (needsEntry)
      newEntry();
  }
  if (needsEntry)
  {
    if (p->varr)
    {
      p->varr = false;
      s->current->name = p->varName;
      s->current->section = EntryType::makeVariableDoc();
      p->varName = "";
    }
    newEntry();
  }
  p->iDocLine = -1;
  p->strComment.clear();
}

References checkInlineCode(), checkMultiComment(), Config_getBool, vhdl::parser::VhdlParser::SharedState::current, DString::empty(), newEntry(), DString::npos, p, VhdlDocGen::prepareComment(), and Markdown::process().

Referenced by initEntry(), and oneLineComment().

handleFlowComment()

void VHDLOutlineParser::handleFlowComment

(

const DString &

doc

)

Definition at line 263 of file vhdljjparser.cpp.

{
  lineCount(doc);
 
  if (VhdlDocGen::getFlowMember())
  {
    DString qcs(doc);
    qcs=qcs.stripWhiteSpace();
    qcs.stripPrefix("--#");
    FlowChart::addFlowChart(FlowChart::COMMENT_NO,DString(),DString(),qcs);
  }
}

References FlowChart::addFlowChart(), FlowChart::COMMENT_NO, DString::DString(), VhdlDocGen::getFlowMember(), lineCount(), DString::stripPrefix(), and DString::stripWhiteSpace().

initEntry()

void VHDLOutlineParser::initEntry

(

Entry *

e

)

Definition at line 198 of file vhdljjparser.cpp.

{
  e->fileName = p->yyFileName;
  e->lang     = SrcLangExt::VHDL;
  if (p->str_doc.pending)
  {
    p->str_doc.pending=false;
    p->oldEntry=nullptr; // prevents endless recursion
    p->iDocLine=p->str_doc.iDocLine;
    handleCommentBlock(p->str_doc.doc,p->str_doc.brief);
    p->iDocLine=-1;
  }
  p->commentScanner.initGroupInfo(e);
}

References Entry::fileName, handleCommentBlock(), Entry::lang, and p.

Referenced by addCompInst(), newEntry(), and parseInput().

insertEntryAtLine()

void VHDLOutlineParser::insertEntryAtLine	(	std::shared_ptr< Entry >	ce,
		int	line )

Definition at line 826 of file vhdljjparser.cpp.

{
  for (const auto &rt : ce->children())
  {
    if (rt->bodyLine==line)
    {
      p->lineEntry.push_back(rt);
    }
 
    insertEntryAtLine(rt,line);
  }
}

References insertEntryAtLine(), and p.

Referenced by checkMultiComment(), and insertEntryAtLine().

isFuncProcProced()

bool VHDLOutlineParser::isFuncProcProced

(

)

Definition at line 602 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  if (s->currP==VhdlSpecifier::FUNCTION  ||
      s->currP==VhdlSpecifier::PROCEDURE ||
      s->currP==VhdlSpecifier::PROCESS
     )
  {
    return true;
  }
  return false;
}

References vhdl::parser::VhdlParser::SharedState::currP, FUNCTION, p, PROCEDURE, and PROCESS.

Referenced by addVhdlType().

lineCount() [1/2]

void VHDLOutlineParser::lineCount

(

)

Definition at line 182 of file vhdljjparser.cpp.

{
  p->yyLineNr++;
}

References p.

lineCount() [2/2]

void VHDLOutlineParser::lineCount

(

const DString &

text

)

Definition at line 187 of file vhdljjparser.cpp.

{
  if (!text.empty())
  {
    for (const char* c=text.data() ; *c ; ++c )
    {
      if (*c == '\n') p->yyLineNr++;
    }
  }
}

References DString::data(), DString::empty(), and p.

Referenced by handleFlowComment().

mapLibPackage()

void VHDLOutlineParser::mapLibPackage

(

Entry *

root

)

Definition at line 682 of file vhdljjparser.cpp.

{
  for (const auto &rt : p->libUse)
  {
    if (addLibUseClause(rt->name))
    {
      bool bFound=false;
      for (const auto &current : root->children())
      {
        if (VhdlDocGen::isVhdlClass(current.get()))
        {
          if (current->startLine > rt->startLine)
          {
            bFound=true;
            current->copyToSubEntry(rt);
            break;
          }
        }
      }//for
      if (!bFound)
      {
        root->copyToSubEntry(rt);
      }
    } //if
  }// for
}//MapLib

References addLibUseClause(), Entry::children(), Entry::copyToSubEntry(), VhdlDocGen::isVhdlClass(), and p.

Referenced by parseInput().

needsPreprocessing()

bool VHDLOutlineParser::needsPreprocessing ( const DString & extension ) const

inlineoverridevirtual

Returns true if the language identified by extension needs the C preprocessor to be run before feed the result to the input parser.

See also

parseInput()

Implements OutlineParserInterface.

Definition at line 30 of file vhdljjparser.h.

{ return true; }

newEntry()

void VHDLOutlineParser::newEntry

(

)

Definition at line 213 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  p->previous = s->current.get();
  if (s->current->vhdlSpec==VhdlSpecifier::ENTITY ||
      s->current->vhdlSpec==VhdlSpecifier::PACKAGE ||
      s->current->vhdlSpec==VhdlSpecifier::ARCHITECTURE ||
      s->current->vhdlSpec==VhdlSpecifier::PACKAGE_BODY)
  {
    s->current_root->moveToSubEntryAndRefresh(s->current);
  }
  else
  {
    if (s->lastCompound)
    {
      s->lastCompound->moveToSubEntryAndRefresh(s->current);
    }
    else
    {
      if (s->lastEntity)
      {
        s->lastEntity->moveToSubEntryAndRefresh(s->current);
      }
      else
      {
        s->current_root->moveToSubEntryAndRefresh(s->current);
      }
    }
  }
  initEntry(s->current.get());
}

References ARCHITECTURE, vhdl::parser::VhdlParser::SharedState::current, vhdl::parser::VhdlParser::SharedState::current_root, ENTITY, initEntry(), vhdl::parser::VhdlParser::SharedState::lastCompound, vhdl::parser::VhdlParser::SharedState::lastEntity, p, PACKAGE, and PACKAGE_BODY.

Referenced by addCompInst(), addVhdlType(), and handleCommentBlock().

oneLineComment()

void VHDLOutlineParser::oneLineComment

(

DString

qcs

)

Definition at line 796 of file vhdljjparser.cpp.

{
    if (size_t j=qcs.find("--!"); j!=DString::npos) qcs=qcs.mid(j+3);
    if (!checkMultiComment(qcs,p->iDocLine))
    {
      handleCommentBlock(qcs,true);
    }
}

References checkMultiComment(), DString::find(), handleCommentBlock(), DString::mid(), DString::npos, and p.

parseInput()

void VHDLOutlineParser::parseInput ( const DString & fileName, const char * fileBuf, const std::shared_ptr< Entry > & root, ClangTUParser * clangParser )

overridevirtual

Parses a single input file with the goal to build an Entry tree.

Parameters

[in]	fileName	The full name of the file.
[in]	fileBuf	The contents of the file (zero terminated).
[in,out]	root	The root of the tree of Entry *nodes representing the information extracted from the file.
[in]	clangParser	The clang translation unit parser object or nullptr if disabled.

Implements OutlineParserInterface.

Definition at line 131 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  p->thisParser=this;
  p->inputString=fileBuf;
 
 // fprintf(stderr,"\n ============= %s\n ==========\n",fileBuf);
 
  bool inLine = fileName.empty();
 
  if (!inLine) msg("Parsing file {}...\n",fileName);
 
  p->yyFileName=fileName;
 
  bool xilinx_ucf=isConstraintFile(p->yyFileName,".ucf");
  bool altera_qsf=isConstraintFile(p->yyFileName,".qsf");
 
  // support XILINX(ucf) and ALTERA (qsf) file
 
  if (xilinx_ucf)
  {
    VhdlDocGen::parseUCF(fileBuf,root.get(),p->yyFileName,false);
    return;
  }
  if (altera_qsf)
  {
    VhdlDocGen::parseUCF(fileBuf,root.get(),p->yyFileName,true);
    return;
  }
  p->yyLineNr=1;
  s->current_root=root;
  s->lastCompound=nullptr;
  s->lastEntity=nullptr;
  p->oldEntry = nullptr;
  s->current=std::make_shared<Entry>();
  initEntry(s->current.get());
  p->commentScanner.enterFile(fileName,p->yyLineNr);
  p->lineParse.reserve(200);
  p->parseVhdlfile(fileName,fileBuf,inLine);
  p->commentScanner.leaveFile(fileName,p->yyLineNr);
 
  s->current.reset();
 
  if (!inLine)
  mapLibPackage(root.get());
 
  p->yyFileName.clear();
  p->libUse.clear();
}

References vhdl::parser::VhdlParser::SharedState::current, vhdl::parser::VhdlParser::SharedState::current_root, DString::empty(), initEntry(), isConstraintFile(), vhdl::parser::VhdlParser::SharedState::lastCompound, vhdl::parser::VhdlParser::SharedState::lastEntity, mapLibPackage(), msg, p, and VhdlDocGen::parseUCF().

parsePrototype()

void VHDLOutlineParser::parsePrototype ( const DString & text )

overridevirtual

Callback function called by the comment block scanner.

It provides a string text containing the prototype of a function or variable. The parser should parse this and store the information in the Entry node that corresponds with the node for which the comment block parser was invoked.

Implements OutlineParserInterface.

Definition at line 471 of file vhdljjparser.cpp.

{
  p->varName=text;
  p->varr=true;
}

References p.

popLabel()

DString VHDLOutlineParser::popLabel

(

DString &

q

)

Definition at line 621 of file vhdljjparser.cpp.

{
  size_t i=q.rfind('|');
  if (i==DString::npos) return DString();
  q = q.left(i);
  return q;
}

References DString::DString(), DString::left(), DString::npos, and DString::rfind().

pushLabel()

void VHDLOutlineParser::pushLabel	(	DString &	label,
		DString &	val )

Definition at line 615 of file vhdljjparser.cpp.

{
  label+="|";
  label+=val;
}

setLineParsed()

void VHDLOutlineParser::setLineParsed

(

int

tok

)

Definition at line 726 of file vhdljjparser.cpp.

{
  if ((int)p->lineParse.size()<=tok) p->lineParse.resize(tok+1);
  p->lineParse[tok]=p->yyLineNr;
}

References p.

setMultCommentLine()

void VHDLOutlineParser::setMultCommentLine

(

)

Definition at line 791 of file vhdljjparser.cpp.

{
  p->iDocLine=p->yyLineNr;
}

References p.

Member Data Documentation

p

std::unique_ptr<Private> VHDLOutlineParser::p

private

Definition at line 64 of file vhdljjparser.h.

Referenced by addCompInst(), addProto(), addVhdlType(), checkInlineCode(), checkMultiComment(), createFlow(), createFunction(), error_skipto(), getLine(), getLine(), handleCommentBlock(), initEntry(), insertEntryAtLine(), isFuncProcProced(), lineCount(), lineCount(), mapLibPackage(), newEntry(), oneLineComment(), parseInput(), parsePrototype(), setLineParsed(), setMultCommentLine(), and VHDLOutlineParser().

---

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

• src/vhdljjparser.h
• src/vhdljjparser.cpp