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 QCString &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 QCString &) 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 QCString &text) override
	Callback function called by the comment block scanner.
void	setLineParsed (int tok)
int	getLine (int tok)
int	getLine ()
void	lineCount (const QCString &)
void	lineCount ()
void	addProto (const QCString &s1, const QCString &s2, const QCString &s3, const QCString &s4, const QCString &s5, const QCString &s6)
void	createFunction (const QCString &impure, VhdlSpecifier spec, const QCString &fname)
void	addVhdlType (const QCString &n, int startLine, EntryType section, VhdlSpecifier spec, const QCString &args, const QCString &type, Protection prot)
void	addCompInst (const QCString &n, const QCString &instName, const QCString &comp, int iLine)
void	handleCommentBlock (const QCString &doc, bool brief)
void	handleFlowComment (const QCString &)
void	initEntry (Entry *e)
void	newEntry ()
bool	isFuncProcProced ()
void	pushLabel (QCString &, QCString &)
QCString	popLabel (QCString &q)
bool	addLibUseClause (const QCString &type)
void	mapLibPackage (Entry *root)
void	createFlow ()
void	error_skipto (int kind)
void	oneLineComment (QCString qcs)
void	setMultCommentLine ()
bool	checkMultiComment (QCString &qcs, int line)
void	insertEntryAtLine (std::shared_ptr< Entry > ce, int line)
QCString	getNameID ()
	returns a unique id for each record member.
int	checkInlineCode (QCString &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 27 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 QCString &	n,
		const QCString &	instName,
		const QCString &	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
  int u=s->genLabels.find("|",1);
  if (u>0)
  {
    s->current->write=s->genLabels.right(s->genLabels.length()-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, QCString::find(), g_instFiles, vhdl::parser::VhdlParser::SharedState::genLabels, initEntry(), INSTANTIATION, vhdl::parser::VhdlParser::SharedState::lastCompound, QCString::left(), QCString::length(), QCString::lower(), newEntry(), p, and QCString::right().

addLibUseClause()

bool VHDLOutlineParser::addLibUseClause

(

const QCString &

type

)

Definition at line 710 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, FALSE, QCString::lower(), QCString::stripPrefix(), and TRUE.

Referenced by mapLibPackage().

addProto()

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

Definition at line 631 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  (void)s5; // avoid unused warning
  StringVector ql=split(s2.str(),",");
 
  for (const auto &n : ql)
  {
    Argument arg;
    arg.name=n;
    if (!s3.isEmpty())
    {
      arg.type=s3;
    }
    arg.type+=" ";
    arg.type+=s4;
    if (!s6.isEmpty())
    {
      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, GEN_SEC, QCString::isEmpty(), Argument::name, p, PARAM_SEC, vhdl::parser::VhdlParser::SharedState::param_sec, vhdl::parser::VhdlParser::SharedState::parse_sec, split(), QCString::str(), Argument::type, and UNKNOWN.

addVhdlType()

void VHDLOutlineParser::addVhdlType	(	const QCString &	n,
		int	startLine,
		EntryType	section,
		VhdlSpecifier	spec,
		const QCString &	args,
		const QCString &	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.isEmpty())
    {
      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(), QCString::str(), and USE.

checkInlineCode()

int VHDLOutlineParser::checkInlineCode

(

QCString &

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 QCString &str,const reg::Ex &re,int pos=0) -> int
  {
    if ((int)str.length()<pos) return -1;
    reg::Match match;
    if (reg::search(str.str(),match,re,pos)) // match found
    {
      return (int)match.position();
    }
    else // not found
    {
      return -1;
    }
  };
  auto replaceRe = [](const QCString &str,const reg::Ex &re,const QCString &replacement) -> QCString
  {
    return reg::replace(str.str(), re, replacement.str());
  };
 
  int index = findRe(doc,csRe);
 
  if (findRe(doc,cendRe)!=-1)
    return 1;
 
  if (index < 0)
    return index;
 
  VhdlParser::SharedState *s = &p->shared;
  p->strComment += doc;
  p->code = findRe(p->inputString,csRe, p->code + 1);
  int com = p->inputString.find(p->strComment.data());
  int ref = findRe(p->inputString,cendRe, p->code + 1);
  int len = static_cast<int>(p->strComment.size());
 
  int ll = com + len;
  int diff = ref - ll - 3;
  QCString 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");
 
  QCString co;
  QCString na;
  for (const auto &qcs_ : ql)
  {
    QCString qcs(qcs_);
    qcs = qcs.simplifyWhiteSpace();
    if (findRe(qcs,csRe)!=-1)
    {
      int i = qcs.find('{');
      int j = qcs.find('}');
      if (i > 0 && j > 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.isEmpty())
    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, QCString::contains(), vhdl::parser::VhdlParser::SharedState::current_root, Entry::doc, Entry::endBodyLine, Entry::fileName, QCString::find(), VhdlDocGen::getRecordNumber(), Entry::inbodyDocs, QCString::isEmpty(), Entry::lang, vhdl::parser::VhdlParser::SharedState::lastCompound, vhdl::parser::VhdlParser::SharedState::lastEntity, QCString::length(), QCString::mid(), MISCELLANEOUS, Entry::name, p, VhdlDocGen::prepareComment(), reg::replace(), reg::search(), Entry::section, QCString::simplifyWhiteSpace(), split(), Entry::startLine, QCString::str(), stripLeadingAndTrailingEmptyLines(), Entry::type, and Entry::vhdlSpec.

Referenced by handleCommentBlock().

checkMultiComment()

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

Definition at line 808 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 742 of file vhdljjparser.cpp.

{
  VhdlParser::SharedState *s = &p->shared;
  if (!VhdlDocGen::getFlowMember())
  {
    return;
  }
  QCString 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,QCString());
 
  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,QCString());
  //  FlowChart::printFlowList();
  FlowChart::writeFlowChart();
  s->currP=VhdlSpecifier::UNKNOWN;
}

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

createFunction()

void VHDLOutlineParser::createFunction	(	const QCString &	impure,
		VhdlSpecifier	spec,
		const QCString &	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.isEmpty())
    {
      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(), GEN_SEC, GENERIC, QCString::isEmpty(), Argument::name, p, vhdl::parser::VhdlParser::SharedState::parse_sec, PROCEDURE, PROCESS, split(), and QCString::str().

error_skipto()

void VHDLOutlineParser::error_skipto

(

int

kind

)

Definition at line 846 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 722 of file vhdljjparser.cpp.

{
  return p->yyLineNr;
}

References p.

getLine() [2/2]

int VHDLOutlineParser::getLine

(

int

tok

)

Definition at line 733 of file vhdljjparser.cpp.

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

References p.

getNameID()

QCString 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 QCString().setNum(idCounter++);
}

References idCounter, and QCString::setNum().

handleCommentBlock()

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

Definition at line 385 of file vhdljjparser.cpp.

{
  int position = 0;
  bool needsEntry = FALSE;
  VhdlParser::SharedState *s = &p->shared;
  QCString doc = doc1;
 
  if (doc.isEmpty())
    return;
 
  if (checkMultiComment(doc, p->yyLineNr))
  {
    p->strComment.clear();
    return;
  }
 
  if (checkInlineCode(doc) > 0)
  {
    return;
  }
 
  Protection protection = Protection::Public;
  VhdlDocGen::prepareComment(doc);
  if (doc.isEmpty()) 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;
  QCString 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, FALSE, QCString::isEmpty(), newEntry(), p, VhdlDocGen::prepareComment(), Markdown::process(), and TRUE.

Referenced by initEntry(), and oneLineComment().

handleFlowComment()

void VHDLOutlineParser::handleFlowComment

(

const QCString &

doc

)

Definition at line 263 of file vhdljjparser.cpp.

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

References FlowChart::addFlowChart(), FlowChart::COMMENT_NO, VhdlDocGen::getFlowMember(), lineCount(), QCString::stripPrefix(), and QCString::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 FALSE, 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 828 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, FALSE, FUNCTION, p, PROCEDURE, PROCESS, and TRUE.

Referenced by addVhdlType().

lineCount() [1/2]

void VHDLOutlineParser::lineCount

(

)

Definition at line 182 of file vhdljjparser.cpp.

{
  p->yyLineNr++;
}

References p.

Referenced by handleFlowComment().

lineCount() [2/2]

void VHDLOutlineParser::lineCount

(

const QCString &

text

)

Definition at line 187 of file vhdljjparser.cpp.

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

References QCString::data(), QCString::isEmpty(), and p.

mapLibPackage()

void VHDLOutlineParser::mapLibPackage

(

Entry *

root

)

Definition at line 683 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(), FALSE, VhdlDocGen::isVhdlClass(), p, and TRUE.

Referenced by parseInput().

needsPreprocessing()

bool VHDLOutlineParser::needsPreprocessing ( const QCString & 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 38 of file vhdljjparser.h.

{ return TRUE; }

References 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

(

QCString

qcs

)

Definition at line 797 of file vhdljjparser.cpp.

{
    int j=qcs.find("--!");
    qcs=qcs.right(qcs.length()-3-j);
    if (!checkMultiComment(qcs,p->iDocLine))
    {
      handleCommentBlock(qcs,TRUE);
    }
}

References checkMultiComment(), QCString::find(), handleCommentBlock(), QCString::length(), p, QCString::right(), and TRUE.

parseInput()

void VHDLOutlineParser::parseInput ( const QCString & 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.isEmpty();
 
  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, FALSE, initEntry(), isConstraintFile(), QCString::isEmpty(), vhdl::parser::VhdlParser::SharedState::lastCompound, vhdl::parser::VhdlParser::SharedState::lastEntity, mapLibPackage(), msg, p, VhdlDocGen::parseUCF(), and TRUE.

parsePrototype()

void VHDLOutlineParser::parsePrototype ( const QCString & 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, and TRUE.

popLabel()

QCString VHDLOutlineParser::popLabel

(

QCString &

q

)

Definition at line 621 of file vhdljjparser.cpp.

{
  int i=q.findRev("|");
  if (i<0) return QCString();
  q = q.left(i);
  return q;
}

References QCString::findRev(), and QCString::left().

pushLabel()

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

Definition at line 615 of file vhdljjparser.cpp.

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

setLineParsed()

void VHDLOutlineParser::setLineParsed

(

int

tok

)

Definition at line 727 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 792 of file vhdljjparser.cpp.

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

References p.

Member Data Documentation

p

std::unique_ptr<Private> VHDLOutlineParser::p

private

Definition at line 72 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