Make VHDL parser reentrant

14 files changed, 2158 insertions, 2237 deletions

diff --git a/src/entry.h b/src/entry.h
index 0391075..802a212 100644
--- a/src/entry.h
+++ b/src/entry.h
@@ -337,4 +337,6 @@ class Entry
     FileDef       *m_fileDef;
 };
 
+typedef std::vector< std::shared_ptr<Entry> > EntryList;
+
 #endif
diff --git a/src/fortranscanner.l b/src/fortranscanner.l
index 18cfdcb..d0ca22d 100644
--- a/src/fortranscanner.l
+++ b/src/fortranscanner.l
@@ -143,8 +143,6 @@ struct CommentInPrepass
   CommentInPrepass(int column, QCString str) : column(column), str(str) {}
 };
 
-typedef std::vector< std::shared_ptr<Entry> > EntryList;
-
 /* -----------------------------------------------------------------
  *
  *      statics
diff --git a/src/vhdldocgen.cpp b/src/vhdldocgen.cpp
index 3c30174..4619b7a 100644
--- a/src/vhdldocgen.cpp
+++ b/src/vhdldocgen.cpp
@@ -2727,29 +2727,7 @@ void assignBinding(VhdlConfNode * conf)
   entBind=conf->binding;
   QCString conf2=VhdlDocGen::parseForBinding(entBind,arcBind);
 
-  if (qstricmp(conf2,"configuration")==0)
-  {
-    QList<VhdlConfNode> confList =  getVhdlConfiguration();
-    VhdlConfNode* vconf;
-    //  bool found=false;
-    for (uint iter=0;iter<confList.count(); iter++)
-    {
-      vconf= (VhdlConfNode *)confList.at(iter);
-      QCString n=VhdlDocGen::getIndexWord(vconf->confVhdl.data(),0);
-      if (n==entBind)
-      {
-        // found=true;
-        entBind=VhdlDocGen::getIndexWord(vconf->confVhdl.data(),1);
-        QCString a=VhdlDocGen::getIndexWord(conf->compSpec.data(),0);
-        QCString e=VhdlDocGen::getIndexWord(conf->confVhdl.data(),1);
-        a=e+"::"+a;
-        archClass= VhdlDocGen::findVhdlClass(a.data());//Doxygen::classSDict->find(a.data());
-        entClass= VhdlDocGen::findVhdlClass(e.data());//Doxygen::classSDict->find(e.data());
-        break;
-      }
-    }
-  }
-  else  // conf2!=configuration
+  if (conf2!="configuration")
   {
     QCString a,c,e;
     if (conf->isInlineConf)
@@ -2852,17 +2830,6 @@ void VhdlDocGen::computeVhdlComponentRelations()
 {
 
   QCString entity,arch,inst;
-  QList<VhdlConfNode> confList =  getVhdlConfiguration();
-
-  for (uint iter=0;iter<confList.count(); iter++)
-  {
-    VhdlConfNode* conf= (VhdlConfNode *)confList.at(iter);
-    if (!(conf->isInlineConf || conf->isLeaf))
-    {
-      continue;
-    }
-    assignBinding(conf);
-  }
 
   for (const auto &cur : getVhdlInstList())
   {
@@ -3630,7 +3597,7 @@ void FlowChart::addFlowChart(int type,const char* text,const char* exp, const ch
 
   FlowChart *fl=new FlowChart(type,typeString.data(),expression.data(),label);
 
-  fl->line=vhdl::parser::VhdlParser::getLine();
+  fl->line=1; // TODO: use getLine(); of the parser
 
   if (type & (START_NO | VARIABLE_NO))
   {
diff --git a/src/vhdldocgen.h b/src/vhdldocgen.h
index 6203196..a557c27 100644
--- a/src/vhdldocgen.h
+++ b/src/vhdldocgen.h
@@ -39,6 +39,33 @@ class FileDef;
 class NamespaceDef;
 struct Argument;
 
+
+
+struct VhdlConfNode
+{ 
+  VhdlConfNode(const char*  a,const char*  b,const char* config,const char* cs,bool leaf) 
+  { 
+    arch=a;              // architecture  e.g. for iobuffer
+    arch=arch.lower();
+    binding=b;           // binding e.g.  use entity work.xxx(bev)
+    binding=binding.lower();
+    confVhdl=config;     // configuration foo is bar
+    compSpec=cs;        
+    isInlineConf=false;  // primary configuration?
+    isLeaf=leaf;
+  };
+
+  QCString confVhdl;
+  QCString arch;
+  QCString binding;
+  QCString compSpec;
+  int level = 0;
+  bool isLeaf = false;
+  bool isInlineConf = false;
+
+};
+
+
 /** Class for generating documentation specific for VHDL */
 class VhdlDocGen  
 {
diff --git a/src/vhdljjparser.cpp b/src/vhdljjparser.cpp
index c79bb5c..a7bac68 100644
--- a/src/vhdljjparser.cpp
+++ b/src/vhdljjparser.cpp
@@ -28,207 +28,213 @@
 #include "outputlist.h"
 #include "arguments.h"
 #include "types.h"
-#include "VhdlParserIF.h"
 #include "growbuf.h"
 #include "markdown.h"
+#include "VhdlParserTokenManager.h"
+#include "VhdlParserErrorHandler.hpp"
 
 using namespace vhdl::parser;
-using namespace std;
-
-static OutlineParserInterface *g_thisParser;
-static CommentScanner g_commentScanner;
-
-static QCString         yyFileName;
-static int              yyLineNr      = 1;
-static int*             lineParse;
-static int              iDocLine      = -1;
-static QCString         inputString;
-static Entry*           gBlock        = 0;
-static Entry*           previous      = 0;
-//-------------------------------------------------------
-
-static Entry* oldEntry;
-static bool varr=FALSE;
-static QCString varName;
-
-static std::vector< std::shared_ptr<Entry> > instFiles;
-static std::vector< std::shared_ptr<Entry> > libUse;
-static std::vector<Entry*> lineEntry;
-
-Entry*   VhdlParser::tempEntry=0;
-Entry*   VhdlParser::lastEntity=0  ;
-Entry*   VhdlParser::lastCompound=0  ;
-Entry*   VhdlParser::current_root  = 0;
-std::shared_ptr<Entry> VhdlParser::current=0;
-QCString VhdlParser::compSpec;
-QCString VhdlParser::currName;
-QCString VhdlParser::confName;
-QCString VhdlParser::genLabels;
-QCString VhdlParser::lab;
-QCString VhdlParser::forL;
 
-int VhdlParser::param_sec = 0;
-int VhdlParser::parse_sec=0;
-int VhdlParser::currP=0;
-int VhdlParser::levelCounter;
-
-static QList<VhdlConfNode> configL;
-
-static struct
+struct VHDLDocInfo
 {
   QCString doc;
   bool brief;
-  bool pending;
-  int iDocLine;
-} str_doc;
+  bool pending = false;
+  int iDocLine = 1;
+};
 
-static QCString strComment;
-static int iCodeLen;
-static const char *vhdlFileName = 0;
 
-static bool checkMultiComment(QCString& qcs,int line);
-static void insertEntryAtLine(const Entry* ce,int line);
+static bool isConstraintFile(const QCString &fileName,const QCString &ext)
+{
+  return fileName.right(ext.length())==ext;
+}
+
 
 //-------------------------------------
 
-const QList<VhdlConfNode>& getVhdlConfiguration() { return  configL; }
-const std::vector<std::shared_ptr<Entry> > &getVhdlInstList() { return  instFiles; }
+static EntryList g_instFiles;
 
-Entry* getVhdlCompound()
+struct VHDLOutlineParser::Private
 {
-  if (VhdlParser::lastEntity) return VhdlParser::lastEntity;
-  if (VhdlParser::lastCompound) return VhdlParser::lastCompound;
-  return NULL;
+  void parseVhdlfile(const char *fileName,const char* inputBuffer,bool inLine);
+
+  VHDLOutlineParser      *thisParser = 0;
+  VhdlParser             *vhdlParser = 0;
+  CommentScanner          commentScanner;
+
+  QCString                yyFileName;
+  int                     yyLineNr      = 1;
+  std::vector<int>        lineParse;
+  int                     iDocLine      = -1;
+  QCString                inputString;
+  Entry*                  gBlock        = 0;
+  Entry*                  previous      = 0;
+//-------------------------------------------------------
+
+  Entry*                  oldEntry = 0;
+  bool                    varr = FALSE;
+  QCString                varName;
+  EntryList               libUse;
+  EntryList               lineEntry;
+  QCString                strComment;
+  int                     iCodeLen;
+  VHDLDocInfo             str_doc;
+  VhdlParser::SharedState shared;
+  QCString                forL;
+
+};
+
+void VHDLOutlineParser::Private::parseVhdlfile(const char *fileName,
+                                               const char* inputBuffer,bool inLine) 
+{
+  JAVACC_STRING_TYPE s =inputBuffer;
+  CharStream *stream = new CharStream(s.c_str(), (int)s.size(), 1, 1);
+  VhdlParserTokenManager *tokenManager = new VhdlParserTokenManager(stream);
+  VhdlTokenManagerErrorHandler *tokErrHandler=new VhdlTokenManagerErrorHandler(fileName);
+  vhdlParser=new VhdlParser(tokenManager);
+  vhdlParser->setOutlineParser(thisParser);
+  vhdlParser->setSharedState(&shared);
+  tokenManager->ReInit(stream,0,vhdlParser);
+  tokenManager->setErrorHandler(tokErrHandler);
+  VhdlErrorHandler *parserErrHandler=new VhdlErrorHandler(fileName);
+  vhdlParser->setErrorHandler(parserErrHandler);
+  try
+  {
+    if(inLine)
+    {
+      vhdlParser->parseInline();
+    }
+    else
+    {
+      vhdlParser->design_file();
+    }
+  }
+  catch( std::exception &){ /* fprintf(stderr,"\n[%s]",e.what()); */ }
+  //  fprintf(stderr,"\n\nparsed lines: %d\n",yyLineNr);
+  //  fprintf(stderr,"\n\nerrors : %d\n\n",myErr->getErrorCount());
+  delete vhdlParser;
 }
 
-bool isConstraintFile(const QCString &fileName,const QCString &ext)
+VHDLOutlineParser::VHDLOutlineParser() : p(std::make_unique<Private>())
 {
-  return fileName.right(ext.length())==ext;
 }
 
+VHDLOutlineParser::~VHDLOutlineParser()
+{
+}
 
 void VHDLOutlineParser::parseInput(const char *fileName,const char *fileBuf,
-                          const std::shared_ptr<Entry> &root, bool ,QStrList&)
+                                   const std::shared_ptr<Entry> &root, bool ,QStrList&)
 {
-  g_thisParser=this;
-  bool inLine=false;
-  inputString=fileBuf;
+  VhdlParser::SharedState *s = &p->shared;
+  p->thisParser=this;
+  p->inputString=fileBuf;
 
  // fprintf(stderr,"\n ============= %s\n ==========\n",fileBuf);
 
-  if (strlen(fileName)==0)
-  {
-    inLine=true;
-  }
+  bool inLine = (fileName==0 || strlen(fileName)==0);
 
-  yyFileName+=fileName;
+  p->yyFileName=fileName;
 
-  bool xilinx_ucf=isConstraintFile(yyFileName,".ucf");
-  bool altera_qsf=isConstraintFile(yyFileName,".qsf");
+  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(),yyFileName,FALSE);
+    VhdlDocGen::parseUCF(fileBuf,root.get(),p->yyFileName,FALSE);
     return;
   }
   if (altera_qsf)
   {
-    VhdlDocGen::parseUCF(fileBuf,root.get(),yyFileName,TRUE);
+    VhdlDocGen::parseUCF(fileBuf,root.get(),p->yyFileName,TRUE);
     return;
   }
-  yyLineNr=1;
-  VhdlParser::current_root=root.get();
-  VhdlParser::lastCompound=0;
-  VhdlParser::lastEntity=0;
-  VhdlParser::lastEntity=0;
-  oldEntry = 0;
-  VhdlParser::current=std::make_shared<Entry>();
-  VhdlParser::initEntry(VhdlParser::current.get());
-  Doxygen::docGroup.enterFile(fileName,yyLineNr);
-  vhdlFileName = fileName;
-  lineParse=new int[200]; // Dimitri: dangerous constant: should be bigger than largest token id in VhdlParserConstants.h
-  VhdlParserIF::parseVhdlfile(fileBuf,inLine);
-
-  VhdlParser::current.reset();
+  p->yyLineNr=1;
+  s->current_root=root;
+  s->lastCompound=0;
+  s->lastEntity=0;
+  s->lastEntity=0;
+  p->oldEntry = 0;
+  s->current=std::make_shared<Entry>();
+  initEntry(s->current.get());
+  Doxygen::docGroup.enterFile(fileName,p->yyLineNr);
+  p->lineParse.reserve(200);
+  p->parseVhdlfile(fileName,fileBuf,inLine);
+
+  s->current.reset();
 
   if (!inLine)
-  VhdlParser::mapLibPackage(root.get());
+  mapLibPackage(root.get());
 
-  delete[] lineParse;
-  yyFileName.resize(0);
-  libUse.clear();
-  VhdlDocGen::resetCodeVhdlParserState();
-  vhdlFileName = 0;
+  p->yyFileName.resize(0);
+  p->libUse.clear();
 }
 
-void VhdlParser::lineCount()
+void VHDLOutlineParser::lineCount()
 {
-  yyLineNr++;
+  p->yyLineNr++;
 }
 
-void VhdlParser::lineCount(const char* text)
+void VHDLOutlineParser::lineCount(const char* text)
 {
   for (const char* c=text ; *c ; ++c )
   {
-    if (*c == '\n') yyLineNr++;
+    if (*c == '\n') p->yyLineNr++;
   }
 }
 
-void isVhdlDocPending()
-{
-  if (!str_doc.pending) return;
-
-  str_doc.pending=FALSE;
-  oldEntry=0; // prevents endless recursion
-  iDocLine=str_doc.iDocLine;
-  VhdlParser::handleCommentBlock(str_doc.doc,str_doc.brief);
-  iDocLine=-1;
-}
-
-void VhdlParser::initEntry(Entry *e)
+void VHDLOutlineParser::initEntry(Entry *e)
 {
-  e->fileName = yyFileName;
+  e->fileName = p->yyFileName;
   e->lang     = SrcLangExt_VHDL;
-  isVhdlDocPending();
+  if (p->str_doc.pending)
+  {
+    p->str_doc.pending=FALSE;
+    p->oldEntry=0; // prevents endless recursion
+    p->iDocLine=p->str_doc.iDocLine;
+    handleCommentBlock(p->str_doc.doc,p->str_doc.brief);
+    p->iDocLine=-1;
+  }
   Doxygen::docGroup.initGroupInfo(e);
 }
 
-void VhdlParser::newEntry()
+void VHDLOutlineParser::newEntry()
 {
-  previous = current.get();
-  if (current->spec==VhdlDocGen::ENTITY ||
-      current->spec==VhdlDocGen::PACKAGE ||
-      current->spec==VhdlDocGen::ARCHITECTURE ||
-      current->spec==VhdlDocGen::PACKAGE_BODY)
+  VhdlParser::SharedState *s = &p->shared;
+  p->previous = s->current.get();
+  if (s->current->spec==VhdlDocGen::ENTITY ||
+      s->current->spec==VhdlDocGen::PACKAGE ||
+      s->current->spec==VhdlDocGen::ARCHITECTURE ||
+      s->current->spec==VhdlDocGen::PACKAGE_BODY)
   {
-    current_root->moveToSubEntryAndRefresh(current);
+    s->current_root->moveToSubEntryAndRefresh(s->current);
   }
   else
   {
-    if (lastCompound)
+    if (s->lastCompound)
     {
-      lastCompound->moveToSubEntryAndRefresh(current);
+      s->lastCompound->moveToSubEntryAndRefresh(s->current);
     }
     else
     {
-      if (lastEntity)
+      if (s->lastEntity)
       {
-	lastEntity->moveToSubEntryAndRefresh(current);
+	s->lastEntity->moveToSubEntryAndRefresh(s->current);
       }
       else
       {
-	current_root->moveToSubEntryAndRefresh(current);
+	s->current_root->moveToSubEntryAndRefresh(s->current);
       }
     }
   }
-  initEntry(current.get());
+  initEntry(s->current.get());
 }
 
-void VhdlParser::handleFlowComment(const char* doc)
+void VHDLOutlineParser::handleFlowComment(const char* doc)
 {
-	lineCount(doc);
+  lineCount(doc);
 
   if (VhdlDocGen::getFlowMember())
   {
@@ -240,16 +246,16 @@ void VhdlParser::handleFlowComment(const char* doc)
 }
 
 
-void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
+void VHDLOutlineParser::handleCommentBlock(const char* doc1,bool brief)
 {
-  QCString doc;
-  doc.append(doc1);
+  VhdlParser::SharedState *s = &p->shared;
+  QCString doc = doc1;
  // fprintf(stderr,"\n %s",doc.data());
   if (doc.isEmpty()) return;
 
-  if (checkMultiComment(doc,yyLineNr))
+  if (checkMultiComment(doc,p->yyLineNr))
   {
-    strComment.resize(0);
+    p->strComment.resize(0);
     return;
   }
 
@@ -257,44 +263,44 @@ void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
 
   Protection protection=Public;
 
-  if (oldEntry==current.get())
+  if (p->oldEntry==s->current.get())
   {
     //printf("\n find pending message  < %s > at line: %d \n ",doc.data(),iDocLine);
-    str_doc.doc=doc;
-    str_doc.iDocLine=iDocLine;
-    str_doc.brief=brief;
-    str_doc.pending=TRUE;
+    p->str_doc.doc=doc;
+    p->str_doc.iDocLine=p->iDocLine;
+    p->str_doc.brief=brief;
+    p->str_doc.pending=TRUE;
     return;
   }
 
-  oldEntry=current.get();
+  p->oldEntry=s->current.get();
 
   if (brief)
   {
-    current->briefLine = yyLineNr;
+    s->current->briefLine = p->yyLineNr;
   }
   else
   {
-    current->docLine = yyLineNr;
+    s->current->docLine = p->yyLineNr;
   }
-  //  printf("parseCommentBlock file<%s>\n [%s]\n at line [%d] \n ",yyFileName.data(),doc.data(),iDocLine);
+  //  printf("parseCommentBlock file<%s>\n [%s]\n at line [%d] \n ",yyFileName.data(),doc.data(),p->iDocLine);
 
   int j=doc.find("[plant]");
   if (j>=0)
   {
     doc=doc.remove(j,7);
-    current->stat=true;
+    s->current->stat=true;
   }
 
   int position=0;
   bool needsEntry=FALSE;
-  QCString processedDoc = processMarkdownForCommentBlock(doc,yyFileName,iDocLine);
-  while (g_commentScanner.parseCommentBlock(
-        g_thisParser,
-        current.get(),
+  QCString processedDoc = processMarkdownForCommentBlock(doc,p->yyFileName,p->iDocLine);
+  while (p->commentScanner.parseCommentBlock(
+        p->thisParser,
+        s->current.get(),
         processedDoc, // text
-        yyFileName, // file
-        iDocLine,   // line of block start
+        p->yyFileName, // file
+        p->iDocLine,   // line of block start
         brief,
         0,
         FALSE,
@@ -309,57 +315,60 @@ void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
   }
   if (needsEntry)
   {
-    if (varr)
+    if (p->varr)
     {
-      varr=FALSE;
-      current->name=varName;
-      current->section=Entry::VARIABLEDOC_SEC;
-      varName="";
+      p->varr=FALSE;
+      s->current->name=p->varName;
+      s->current->section=Entry::VARIABLEDOC_SEC;
+      p->varName="";
     }
     newEntry();
   }
-  iDocLine=-1;
-  strComment.resize(0);
+  p->iDocLine=-1;
+  p->strComment.resize(0);
 }
 
 void VHDLOutlineParser::parsePrototype(const char *text)
 {
-  varName=text;
-  varr=TRUE;
+  p->varName=text;
+  p->varr=TRUE;
 }
 
-void VhdlParser::addCompInst(const char *n, const char* instName, const char* comp,int iLine)
+void VHDLOutlineParser::addCompInst(const char *n, const char* instName, const char* comp,int iLine)
 {
-  current->spec=VhdlDocGen::INSTANTIATION;
-  current->section=Entry::VARIABLE_SEC;
-  current->startLine=iLine;
-  current->bodyLine=iLine;
-  current->type=instName;                       // foo:instname e.g proto or work. proto(ttt)
-  current->exception=genLabels.lower();         // |arch|label1:label2...
-  current->name=n;                              // foo
-  if (lastCompound)
+  VhdlParser::SharedState *s = &p->shared;
+  s->current->spec=VhdlDocGen::INSTANTIATION;
+  s->current->section=Entry::VARIABLE_SEC;
+  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)
   {
-    current->args=lastCompound->name;             // architecture name
+    s->current->args=s->lastCompound->name;             // architecture name
   }
-  current->includeName=comp;                    // component/entity/configuration
-  int u=genLabels.find("|",1);
+  s->current->includeName=comp;                    // component/entity/configuration
+  int u=s->genLabels.find("|",1);
   if (u>0)
   {
-    current->write=genLabels.right(genLabels.length()-u);
-    current->read=genLabels.left(u);
+    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 (lastCompound)
+  if (s->lastCompound)
   {
-    current->args=lastCompound->name;
+    s->current->args=s->lastCompound->name;
     if (true) // !findInstant(current->type))
     {
-      initEntry(current.get());
-      instFiles.emplace_back(std::make_shared<Entry>(*current));
+      initEntry(s->current.get());
+      // TODO: protect with mutex
+      g_instFiles.emplace_back(std::make_shared<Entry>(*s->current));
+      // TODO: end protect with mutex
     }
 
-    current=std::make_shared<Entry>();
+    s->current=std::make_shared<Entry>();
   }
   else
   {
@@ -367,13 +376,14 @@ void VhdlParser::addCompInst(const char *n, const char* instName, const char* co
   }
 }
 
-void VhdlParser::addVhdlType(const char *n,int startLine,int section,
+void VHDLOutlineParser::addVhdlType(const char *n,int startLine,int section,
     uint64 spec,const char* args,const char* type,Protection prot)
 {
+  VhdlParser::SharedState *s = &p->shared;
   QCString name(n);
   if (isFuncProcProced() || VhdlDocGen::getFlowMember())  return;
 
-  if (parse_sec==GEN_SEC)
+  if (s->parse_sec==GEN_SEC)
   {
     spec= VhdlDocGen::GENERIC;
   }
@@ -382,61 +392,62 @@ void VhdlParser::addVhdlType(const char *n,int startLine,int section,
 
   for (uint u=0;u<ql.count();u++)
   {
-    current->name=ql[u];
-    current->startLine=startLine;
-    current->bodyLine=startLine;
-    current->section=section;
-    current->spec=spec;
-    current->fileName=yyFileName;
-    if (current->args.isEmpty())
+    s->current->name=ql[u];
+    s->current->startLine=startLine;
+    s->current->bodyLine=startLine;
+    s->current->section=section;
+    s->current->spec=spec;
+    s->current->fileName=p->yyFileName;
+    if (s->current->args.isEmpty())
     {
-      current->args=args;
+      s->current->args=args;
     }
-    current->type=type;
-    current->protection=prot;
+    s->current->type=type;
+    s->current->protection=prot;
 
-    if (!lastCompound && (section==Entry::VARIABLE_SEC) &&  (spec == VhdlDocGen::USE || spec == VhdlDocGen::LIBRARY) )
+    if (!s->lastCompound && (section==Entry::VARIABLE_SEC) &&  (spec == VhdlDocGen::USE || spec == VhdlDocGen::LIBRARY) )
     {
-      libUse.emplace_back(std::make_shared<Entry>(*current));
-      current->reset();
+      p->libUse.emplace_back(std::make_shared<Entry>(*s->current));
+      s->current->reset();
     }
     newEntry();
   }
 }
 
-void VhdlParser::createFunction(const char *imp,uint64 spec,const char *fn)
+void VHDLOutlineParser::createFunction(const char *imp,uint64 spec,const char *fn)
 {
+  VhdlParser::SharedState *s = &p->shared;
   QCString impure(imp);
   QCString fname(fn);
-  current->spec=spec;
-  current->section=Entry::FUNCTION_SEC;
+  s->current->spec=spec;
+  s->current->section=Entry::FUNCTION_SEC;
 
   if (impure=="impure" || impure=="pure")
   {
-    current->exception=impure;
+    s->current->exception=impure;
   }
 
-  if (parse_sec==GEN_SEC)
+  if (s->parse_sec==GEN_SEC)
   {
-    current->spec= VhdlDocGen::GENERIC;
-    current->section=Entry::FUNCTION_SEC;
+    s->current->spec= VhdlDocGen::GENERIC;
+    s->current->section=Entry::FUNCTION_SEC;
   }
 
-  if (currP==VhdlDocGen::PROCEDURE)
+  if (s->currP==VhdlDocGen::PROCEDURE)
   {
-    current->name=impure;
-    current->exception="";
+    s->current->name=impure;
+    s->current->exception="";
   }
   else
   {
-    current->name=fname;
+    s->current->name=fname;
   }
 
   if (spec==VhdlDocGen::PROCESS)
   {
-    current->args=fname;
-    current->name=impure;
-    VhdlDocGen::deleteAllChars(current->args,' ');
+    s->current->args=fname;
+    s->current->name=impure;
+    VhdlDocGen::deleteAllChars(s->current->args,' ');
     if (!fname.isEmpty())
     {
       QCStringList q1=QCStringList::split(",",fname);
@@ -444,19 +455,19 @@ void VhdlParser::createFunction(const char *imp,uint64 spec,const char *fn)
       {
         Argument arg;
         arg.name=q1[ii];
-        current->argList.push_back(arg);
+        s->current->argList.push_back(arg);
       }
     }
-    return;
   }
- }
+}
 
 
-bool VhdlParser::isFuncProcProced()
+bool VHDLOutlineParser::isFuncProcProced()
 {
-  if (currP==VhdlDocGen::FUNCTION  ||
-      currP==VhdlDocGen::PROCEDURE ||
-      currP==VhdlDocGen::PROCESS
+  VhdlParser::SharedState *s = &p->shared;
+  if (s->currP==VhdlDocGen::FUNCTION  ||
+      s->currP==VhdlDocGen::PROCEDURE ||
+      s->currP==VhdlDocGen::PROCESS
      )
   {
     return TRUE;
@@ -464,13 +475,13 @@ bool VhdlParser::isFuncProcProced()
   return FALSE;
 }
 
-void VhdlParser::pushLabel( QCString &label,QCString & val)
+void VHDLOutlineParser::pushLabel( QCString &label,QCString & val)
 {
   label+="|";
   label+=val;
 }
 
- QCString  VhdlParser::popLabel(QCString & q)
+QCString VHDLOutlineParser::popLabel(QCString & q)
 {
   int i=q.findRev("|");
   if (i<0) return "";
@@ -478,63 +489,12 @@ void VhdlParser::pushLabel( QCString &label,QCString & val)
   return q;
 }
 
-void VhdlParser::addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf)
-{
-  VhdlConfNode* co=0;
-  QCString ent;
-  ent=a;
-
-  if (b)
-  {
-    ent=b;
-  }
-  int level=0;
-
-  if (!configL.isEmpty())
-  {
-    VhdlConfNode* vc=configL.getLast();
-    level=vc->level;
-    if (levelCounter==0)
-    {
-      pushLabel(forL,ent);
-    }
-    else if (level<levelCounter)
-    {
-      if (!isLeaf)
-      {
-        pushLabel(forL,ent);
-      }
-    }
-    else if (level>levelCounter)
-    {
-      forL=popLabel(forL);
-    }
-  }
-  else
-  {
-    pushLabel(forL,ent);
-  }
-
-  if (inlineConf)
-  {
-    confName=lastCompound->name;
-  }
-
-  //fprintf(stderr,"\n[%s %d %d]\n",forL.data(),levelCounter,level);
-  co=new VhdlConfNode(a,b,confName.lower().data(),forL.lower().data(),isLeaf);
-
-  if (inlineConf)
-  {
-    co->isInlineConf=TRUE;
-  }
-
-  configL.append(co);
-}
 
 
-void VhdlParser::addProto(const char *s1,const char *s2,const char *s3,
+void VHDLOutlineParser::addProto(const char *s1,const char *s2,const char *s3,
                           const char *s4,const char *s5,const char *s6)
 {
+  VhdlParser::SharedState *s = &p->shared;
   (void)s5; // avoid unused warning
   QCString name=s2;
   QCStringList ql=QCStringList::split(",",name);
@@ -553,12 +513,12 @@ void VhdlParser::addProto(const char *s1,const char *s2,const char *s3,
     {
       arg.type+=s6;
     }
-    if (parse_sec==GEN_SEC && param_sec==0)
+    if (s->parse_sec==GEN_SEC && s->param_sec==0)
     {
       arg.defval="gen!";
     }
 
-    if (parse_sec==PARAM_SEC)
+    if (s->parse_sec==PARAM_SEC)
     {
     //  assert(false);
     }
@@ -566,9 +526,9 @@ void VhdlParser::addProto(const char *s1,const char *s2,const char *s3,
     arg.defval+=s1;
     arg.attrib="";//s6;
 
-    current->argList.push_back(arg);
-    current->args+=s2;
-    current->args+=",";
+    s->current->argList.push_back(arg);
+    s->current->args+=s2;
+    s->current->args+=",";
   }
 }
 
@@ -584,13 +544,13 @@ void VhdlParser::addProto(const char *s1,const char *s2,const char *s3,
  * .....
  * and so on..
  */
-void VhdlParser::mapLibPackage( Entry* root)
+void VHDLOutlineParser::mapLibPackage( Entry* root)
 {
   //QList<Entry> epp=libUse;
   //EntryListIterator eli(epp);
   //Entry *rt;
   //for (;(rt=eli.current());++eli)
-  for (const auto &rt : libUse)
+  for (const auto &rt : p->libUse)
   {
     if (addLibUseClause(rt->name))
     {
@@ -615,7 +575,7 @@ void VhdlParser::mapLibPackage( Entry* root)
   }// for
 }//MapLib
 
-bool VhdlParser::addLibUseClause(const QCString &type)
+bool VHDLOutlineParser::addLibUseClause(const QCString &type)
 {
   static bool showIEEESTD=Config_getBool(FORCE_LOCAL_INCLUDES);
 
@@ -627,48 +587,50 @@ bool VhdlParser::addLibUseClause(const QCString &type)
   return TRUE;
 }
 
-int VhdlParser::getLine()
+int VHDLOutlineParser::getLine()
 {
-  return yyLineNr;
+  return p->yyLineNr;
 }
 
-void VhdlParser::setLineParsed(int tok)
+void VHDLOutlineParser::setLineParsed(int tok)
 {
-  lineParse[tok]=yyLineNr;
+  p->lineParse.reserve(tok+1);
+  p->lineParse[tok]=p->yyLineNr;
 }
 
-int VhdlParser::getLine(int tok)
+int VHDLOutlineParser::getLine(int tok)
 {
-  int val=lineParse[tok];
+  int val=p->lineParse[tok];
   if (val<0) val=0;
   //assert(val>=0 && val<=yyLineNr);
   return val;
 }
 
 
-void VhdlParser::createFlow()
+void VHDLOutlineParser::createFlow()
 {
+  VhdlParser::SharedState *s = &p->shared;
   if (!VhdlDocGen::getFlowMember())
   {
     return;
   }
   QCString q,ret;
 
-  if (currP==VhdlDocGen::FUNCTION)
+  if (s->currP==VhdlDocGen::FUNCTION)
   {
     q=":function( ";
-    FlowChart::alignFuncProc(q,tempEntry->argList,true);
+    FlowChart::alignFuncProc(q,s->tempEntry->argList,true);
     q+=")";
   }
-  else if (currP==VhdlDocGen::PROCEDURE)
+  else if (s->currP==VhdlDocGen::PROCEDURE)
   {
     q=":procedure (";
-    FlowChart::alignFuncProc(q,tempEntry->argList,false);
+    FlowChart::alignFuncProc(q,s->tempEntry->argList,false);
     q+=")";
   }
   else
   {
-    q=":process( "+tempEntry->args;
+    q=":process( "+s->tempEntry->args;
     q+=")";
   }
 
@@ -676,11 +638,11 @@ void VhdlParser::createFlow()
 
   FlowChart::addFlowChart(FlowChart::START_NO,q,0);
 
-  if (currP==VhdlDocGen::FUNCTION)
+  if (s->currP==VhdlDocGen::FUNCTION)
   {
     ret="end function ";
   }
-  else if (currP==VhdlDocGen::PROCEDURE)
+  else if (s->currP==VhdlDocGen::PROCEDURE)
   {
     ret="end procedure";
   }
@@ -692,60 +654,79 @@ void VhdlParser::createFlow()
   FlowChart::addFlowChart(FlowChart::END_NO,ret,0);
   //  FlowChart::printFlowList();
   FlowChart::writeFlowChart();
-  currP=0;
+  s->currP=0;
 }
 
-void VhdlParser::setMultCommentLine()
+void VHDLOutlineParser::setMultCommentLine()
 {
-  iDocLine=yyLineNr;
+  p->iDocLine=p->yyLineNr;
 }
 
-void VhdlParser::oneLineComment(QCString qcs)
+void VHDLOutlineParser::oneLineComment(QCString qcs)
 {
     int j=qcs.find("--!");
     qcs=qcs.right(qcs.length()-3-j);
-    if (!checkMultiComment(qcs,iDocLine))
+    if (!checkMultiComment(qcs,p->iDocLine))
     {
       handleCommentBlock(qcs,TRUE);
     }
 }
 
 
-bool  checkMultiComment(QCString& qcs,int line)
+bool VHDLOutlineParser::checkMultiComment(QCString& qcs,int line)
 {
-  insertEntryAtLine(VhdlParser::current_root,line);
+  VhdlParser::SharedState *s = &p->shared;
+  insertEntryAtLine(s->current_root,line);
 
-  if (lineEntry.empty()) return false;
+  if (p->lineEntry.empty()) return false;
 
   VhdlDocGen::prepareComment(qcs);
-  while (!lineEntry.empty())
+  while (!p->lineEntry.empty())
   {
-    Entry *e=lineEntry.back();
+    std::shared_ptr<Entry> e=p->lineEntry.back();
     e->briefLine=line;
     e->brief+=qcs;
 
-    lineEntry.pop_back();
+    p->lineEntry.pop_back();
   }
   return true;
 }
 
 // returns the vhdl parsed types at line xxx
-void insertEntryAtLine(const Entry* ce,int line)
+void VHDLOutlineParser::insertEntryAtLine(std::shared_ptr<Entry> ce,int line)
 {
   for (const auto &rt : ce->children())
   {
     if (rt->bodyLine==line)
     {
-      lineEntry.push_back(rt.get());
+      p->lineEntry.push_back(rt);
     }
 
-    insertEntryAtLine(rt.get(),line);
+    insertEntryAtLine(rt,line);
   }
 }
 
-const char *getVhdlFileName(void)
+const EntryList &getVhdlInstList()
 {
-  return vhdlFileName;
+  return g_instFiles;
+}
+
+void VHDLOutlineParser::error_skipto(int kind)
+{
+  Token *op;
+  do
+  {
+    Token *t = p->vhdlParser->getNextToken();// step to next token
+    op=p->vhdlParser->getToken(1);           // get first token
+    if (op==0) break;
+    //fprintf(stderr,"\n %s",t->image.data());
+  } 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".
 }
 
 QCString filter2008VhdlComment(const char *s)
diff --git a/src/vhdljjparser.h b/src/vhdljjparser.h
index f3e7d70..9e93e0d 100644
--- a/src/vhdljjparser.h
+++ b/src/vhdljjparser.h
@@ -19,21 +19,10 @@
 #include "entry.h"
 #include "vhdldocgen.h"
 #include "vhdlcode.h"
-#include "memberlist.h"
 #include "config.h"
 
-
-
-
 enum  { GEN_SEC=0x1, PARAM_SEC,CONTEXT_SEC,PROTECTED_SEC } ;
-void  parserVhdlfile(const char* inputBuffer);
-
-class Entry;
-class ClassSDict;
-class ClassDef;
-class MemberDef;
-struct VhdlConfNode;
-
+//void  parserVhdlfile(const char* inputBuffer);
 
 /** \brief VHDL parser using state-based lexical scanning.
  *
@@ -42,7 +31,8 @@ struct VhdlConfNode;
 class VHDLOutlineParser : public OutlineParserInterface
 {
   public:
-    virtual ~VHDLOutlineParser() {}
+    VHDLOutlineParser();
+    virtual ~VHDLOutlineParser();
     void startTranslationUnit(const char *) {}
     void finishTranslationUnit() {}
     void parseInput(const char * fileName,
@@ -53,35 +43,43 @@ class VHDLOutlineParser : public OutlineParserInterface
 
     bool needsPreprocessing(const QCString &) const { return TRUE; }
     void parsePrototype(const char *text);
-};
 
-struct VhdlConfNode
-{ 
-  VhdlConfNode(const char*  a,const char*  b,const char* config,const char* cs,bool leaf) 
-  { 
-    arch=a;              // architecture  e.g. for iobuffer
-    arch=arch.lower();
-    binding=b;           // binding e.g.  use entity work.xxx(bev)
-    binding=binding.lower();
-    confVhdl=config;     // configuration foo is bar
-    compSpec=cs;        
-    isInlineConf=false;  // primary configuration?
-    isLeaf=leaf;
-  };
-
-  QCString confVhdl;
-  QCString arch;
-  QCString binding;
-  QCString compSpec;
-  int level = 0;
-  bool isLeaf = false;
-  bool isInlineConf = false;
 
+    // interface for generated parser code
+
+    void setLineParsed(int tok);
+    int getLine(int tok);
+    int getLine();
+    void lineCount(const char*);
+    void lineCount();
+    void addProto(const char *s1,const char *s2,const char *s3,const char *s4,const char *s5,const char *s6);
+    //void addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf);
+    void createFunction(const char *impure,uint64 spec,const char *fname);
+    void addVhdlType(const char *n,int startLine,int section, uint64 spec,const char* args,const char* type,Protection prot);
+    void addCompInst(const char *n, const char* instName, const char* comp,int iLine);
+    void handleCommentBlock(const char* doc,bool brief);
+    void handleFlowComment(const char*);
+    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);
+
+  private:
+    struct Private;
+    std::unique_ptr<Private> p;
 };
 
-void vhdlscanFreeScanner();
+const EntryList &getVhdlInstList();
 
-const QList<VhdlConfNode>& getVhdlConfiguration();
-const std::vector<std::shared_ptr<Entry> >&getVhdlInstList();
 QCString filter2008VhdlComment(const char *s);
+
 #endif
diff --git a/vhdlparser/CMakeLists.txt b/vhdlparser/CMakeLists.txt
index 43dc74d..d9281c0 100644
--- a/vhdlparser/CMakeLists.txt
+++ b/vhdlparser/CMakeLists.txt
@@ -16,7 +16,6 @@ Token.cc
 TokenMgrError.cc
 VhdlParser.cc
 VhdlParserTokenManager.cc
-VhdlParserIF.cpp
 )
 add_dependencies(vhdlparser
     generate_configvalues_header
diff --git a/vhdlparser/VhdlParser.cc b/vhdlparser/VhdlParser.cc
index b360217..49e9bd9 100644
--- a/vhdlparser/VhdlParser.cc
+++ b/vhdlparser/VhdlParser.cc
@@ -354,7 +354,7 @@ s+=s1;
     jj_consume_token(SEMI_T);
     }
     
-addVhdlType(s2.data(),getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
+outlineParser()->addVhdlType(s2.data(),outlineParser()->getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
 
  return s2+" "+s+";";
 assert(false);
@@ -461,10 +461,10 @@ void VhdlParser::architecture_body() {QCString s,s1;if (!hasError) {
     if (!hasError) {
     
 QCString t=s1+"::"+s;
-                  genLabels.resize(0);
-                  pushLabel(genLabels,s1);
-                  lastCompound=current.get();
-                  addVhdlType(t,getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
+    m_sharedState->genLabels.resize(0);
+    outlineParser()->pushLabel(m_sharedState->genLabels,s1);
+    m_sharedState->lastCompound=m_sharedState->current;
+    outlineParser()->addVhdlType(t,outlineParser()->getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
     }
     if (!hasError) {
     
@@ -474,7 +474,7 @@ QCString t=s1+"::"+s;
       }
       
     } catch ( ...) {
-error_skipto(BEGIN_T);
+outlineParser()->error_skipto(BEGIN_T);
     }
     }
     if (!hasError) {
@@ -527,7 +527,7 @@ error_skipto(BEGIN_T);
     jj_consume_token(SEMI_T);
     }
     
-lastEntity=0;lastCompound=0; genLabels.resize(0);
+m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
 }
 
 
@@ -810,7 +810,7 @@ QCString VhdlParser::attribute_declaration() {QCString s,s1;if (!hasError) {
     jj_consume_token(SEMI_T);
     }
     
-addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
+outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
     return " attribute "+s+":"+s1+";";
 assert(false);
 }
@@ -929,7 +929,7 @@ QCString VhdlParser::attribute_specification() {QCString s,s1,s2;if (!hasError)
     }
     
 QCString t= s1+" is "+s2;
-   addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
+   outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
    return " attribute "+s+" of "+s1+ " is "+s2+";";
 assert(false);
 }
@@ -1417,7 +1417,7 @@ void VhdlParser::block_statement() {QCString s;if (!hasError) {
     }
     if (!hasError) {
     
-pushLabel(genLabels,s);
+outlineParser()->pushLabel(m_sharedState->genLabels,s);
     }
     if (!hasError) {
     
@@ -1502,7 +1502,7 @@ pushLabel(genLabels,s);
     jj_consume_token(SEMI_T);
     }
     
-genLabels=popLabel(genLabels);
+m_sharedState->genLabels=outlineParser()->popLabel(m_sharedState->genLabels);
 }
 
 
@@ -1844,7 +1844,7 @@ void VhdlParser::component_declaration() {QCString s;if (!hasError) {
     }
     if (!hasError) {
     
-currP=VhdlDocGen::COMPONENT;
+m_sharedState->currP=VhdlDocGen::COMPONENT;
     }
     if (!hasError) {
     
@@ -1878,8 +1878,8 @@ currP=VhdlDocGen::COMPONENT;
     }
     if (!hasError) {
     
-addVhdlType(s.data(),getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
-     currP=0;
+outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
+     m_sharedState->currP=0;
     }
     if (!hasError) {
     
@@ -1933,7 +1933,7 @@ QCString s3;
          s1=VhdlDocGen::getIndexWord(s1.data(),1);
        }
 
-       addCompInst(s.lower().data(),s1.lower().data(),s3.data(),getLine());
+       outlineParser()->addCompInst(s.lower().data(),s1.lower().data(),s3.data(),outlineParser()->getLine());
     }
     if (!hasError) {
     
@@ -2350,8 +2350,8 @@ void VhdlParser::configuration_declaration() {QCString s,s1;if (!hasError) {
     }
     if (!hasError) {
     
-confName=s+"::"+s1;
-  addVhdlType(s.data(),getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
+m_sharedState->confName=s+"::"+s1;
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
     }
     if (!hasError) {
     
@@ -2403,7 +2403,7 @@ confName=s+"::"+s1;
     jj_consume_token(SEMI_T);
     }
     
-genLabels.resize(0); confName="";
+m_sharedState->genLabels.resize(0); m_sharedState->confName="";
 }
 
 
@@ -2550,7 +2550,7 @@ QCString VhdlParser::constant_declaration() {QCString s,s1,s2;Token *t=0;if (!ha
 if(t)
       s2.prepend(":=");
      QCString it=s1+s2;
-     addVhdlType(s.data(),getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public);
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public);
      it.prepend("constant ");
      return it;
 assert(false);
@@ -2966,8 +2966,8 @@ QCString VhdlParser::element_declaration() {QCString s,s1;if (!hasError) {
     jj_consume_token(SEMI_T);
     }
     
-addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s1.data(),Public);
-  //addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
+outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s1.data(),Public);
+  //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
   return s+":"+s1;
 assert(false);
 }
@@ -3337,9 +3337,9 @@ void VhdlParser::entity_declaration() {QCString s;if (!hasError) {
     }
     if (!hasError) {
     
-lastEntity=current.get();
-                lastCompound=0;
-                addVhdlType(s.data(),getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
+m_sharedState->lastEntity=m_sharedState->current;
+                m_sharedState->lastCompound=0;
+                outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
     }
     if (!hasError) {
     
@@ -3410,7 +3410,7 @@ lastEntity=current.get();
     jj_consume_token(SEMI_T);
     }
     
-lastEntity=0;lastCompound=0; genLabels.resize(0);
+m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
 }
 
 
@@ -3629,7 +3629,7 @@ void VhdlParser::entity_header() {if (!hasError) {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case GENERIC_T:{if (!hasError) {
       
-currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC;
+m_sharedState->currP=VhdlDocGen::GENERIC;m_sharedState->parse_sec=GEN_SEC;
       }
       if (!hasError) {
       
@@ -3648,7 +3648,7 @@ currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case PORT_T:{if (!hasError) {
       
-currP=VhdlDocGen::PORT;
+m_sharedState->currP=VhdlDocGen::PORT;
       }
       if (!hasError) {
       
@@ -3996,7 +3996,7 @@ QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;i
     jj_consume_token(SEMI_T);
     }
     
-lab.resize(0);
+m_sharedState->lab.resize(0);
   if(t) s+=":";
   if(t1) s2.prepend(" when ");
    FlowChart::addFlowChart(FlowChart::EXIT_NO,"exit",s2.data(),s1.data());
@@ -4259,7 +4259,7 @@ QCString VhdlParser::file_declaration() {QCString s,s1,s2,s3;if (!hasError) {
     }
     
 QCString t1=s2+" "+s3;
-   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
+   outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
    return " file "+s+":"+s2+" "+s3+";";
 assert(false);
 }
@@ -4419,7 +4419,7 @@ assert(false);
 }
 
 
-QCString VhdlParser::full_type_declaration() {Entry *tmpEntry;QCString s,s1,s2;if (!hasError) {
+QCString VhdlParser::full_type_declaration() {std::shared_ptr<Entry> tmpEntry;QCString s,s1,s2;if (!hasError) {
     
     jj_consume_token(TYPE_T);
     }
@@ -4433,8 +4433,8 @@ QCString VhdlParser::full_type_declaration() {Entry *tmpEntry;QCString s,s1,s2;i
     }
     if (!hasError) {
     
-tmpEntry=current.get();
-  addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
+tmpEntry=m_sharedState->current;
+    outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
     }
     if (!hasError) {
     
@@ -4444,7 +4444,7 @@ tmpEntry=current.get();
       }
       
     } catch ( ...) {
-error_skipto(SEMI_T);
+outlineParser()->error_skipto(SEMI_T);
     }
     }
     if (!hasError) {
@@ -4453,24 +4453,24 @@ error_skipto(SEMI_T);
     }
     
 if (s2.contains("#")) {
-        VhdlDocGen::deleteAllChars(s2,'#');
-        tmpEntry->spec=VhdlDocGen::RECORD;
-        tmpEntry->type=s2.data();
-        //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s2.data(),Public);
-      }
-      else if (s2.contains("%")) {
-        VhdlDocGen::deleteAllChars(s2,'%');
-        tmpEntry->spec=VhdlDocGen::UNITS;
-        tmpEntry->type=s2.data();
-        //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,s2.data(),s2.data(),Public);
-      }
-      else {
-        tmpEntry->spec=VhdlDocGen::TYPE;
-        tmpEntry->type=s2.data();
-        //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,s2.data(),Public);
-      }
-      tmpEntry=0;
-      return "type "+s+" is "+s2+";";
+      VhdlDocGen::deleteAllChars(s2,'#');
+      tmpEntry->spec=VhdlDocGen::RECORD;
+      tmpEntry->type=s2.data();
+      //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s2.data(),Public);
+    }
+    else if (s2.contains("%")) {
+      VhdlDocGen::deleteAllChars(s2,'%');
+      tmpEntry->spec=VhdlDocGen::UNITS;
+      tmpEntry->type=s2.data();
+      //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,s2.data(),s2.data(),Public);
+    }
+    else {
+      tmpEntry->spec=VhdlDocGen::TYPE;
+      tmpEntry->type=s2.data();
+      //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,s2.data(),Public);
+    }
+    tmpEntry.reset();
+    return "type "+s+" is "+s2+";";
 assert(false);
 }
 
@@ -4517,7 +4517,7 @@ void VhdlParser::generate_statement() {QCString s;if (!hasError) {
       }
       if (!hasError) {
       
-pushLabel(genLabels,s);
+outlineParser()->pushLabel(m_sharedState->genLabels,s);
       }
       if (!hasError) {
       
@@ -4529,7 +4529,7 @@ pushLabel(genLabels,s);
       }
       
     } catch ( ...) {
-error_skipto(GENERATE_T);
+outlineParser()->error_skipto(GENERATE_T);
     }
     }
     if (!hasError) {
@@ -4557,7 +4557,7 @@ error_skipto(GENERATE_T);
     jj_consume_token(SEMI_T);
     }
     
-genLabels=popLabel(genLabels);
+m_sharedState->genLabels=outlineParser()->popLabel(m_sharedState->genLabels);
 }
 
 
@@ -4603,7 +4603,7 @@ void VhdlParser::generic_clause() {QCString s;if (!hasError) {
     }
     if (!hasError) {
     
-parse_sec=GEN_SEC;
+m_sharedState->parse_sec=GEN_SEC;
     }
     if (!hasError) {
     
@@ -4618,7 +4618,7 @@ parse_sec=GEN_SEC;
     jj_consume_token(SEMI_T);
     }
     
-parse_sec=0;
+m_sharedState->parse_sec=0;
 }
 
 
@@ -4925,7 +4925,7 @@ void VhdlParser::if_statement() {QCString s,s1;if (!hasError) {
     if (!hasError) {
     
 s.prepend("if ");
-    FlowChart::addFlowChart(FlowChart::IF_NO,0,s);
+      FlowChart::addFlowChart(FlowChart::IF_NO,0,s);
     }
     if (!hasError) {
     
@@ -4957,7 +4957,7 @@ s.prepend("if ");
       if (!hasError) {
       
 s1.prepend("elsif ");
-           FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data());
+     FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data());
       }
       if (!hasError) {
       
@@ -5020,7 +5020,7 @@ FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
     }
     
 FlowChart::moveToPrevLevel();
-          FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
+    FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
 }
 
 
@@ -5406,10 +5406,9 @@ return s;
             }
             if (!hasError) {
             
-if (parse_sec==GEN_SEC)
-
-    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,s1.data(),0,Public);
-    return s;
+if (m_sharedState->parse_sec==GEN_SEC)
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,s1.data(),0,Public);
+   return s;
             }
             
             break;
@@ -5453,8 +5452,8 @@ QCString VhdlParser::interface_file_declaration() {QCString s,s1;if (!hasError)
     s1 = subtype_indication();
     }
     
-addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
-   return " file "+s+":"+s1;
+outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
+    return " file "+s+":"+s1;
 assert(false);
 }
 
@@ -5614,32 +5613,32 @@ QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=
     }
     
 if(tok)
-                    s5=tok->image.c_str();
+        s5=tok->image.c_str();
 
-                    if(tok1)
-                     s3=tok1->image.data();
+      if(tok1)
+        s3=tok1->image.data();
 
-                    if(tok2)
-                     s3+=":=";
+      if(tok2)
+        s3+=":=";
 
-                    QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4;
-                    if (currP!=VhdlDocGen::COMPONENT)
-                    {
-                      if (currP==VhdlDocGen::FUNCTION || currP==VhdlDocGen::PROCEDURE)
-                      {
-                        addProto(s5.data(),s.data(),s1.data(),s2.data(),s3.data(),s4.data());
-                      }
-                      else
-                      {
-                        QCString i=s2+s3+s4;
-                        if (currP==VhdlDocGen::GENERIC && param_sec==0)
-                          addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public);
-                        else if(parse_sec != GEN_SEC)
-                          addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public);
-                      }
-                      //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
-                    } // if component
-              return it;
+      QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4;
+      if (m_sharedState->currP!=VhdlDocGen::COMPONENT)
+      {
+        if (m_sharedState->currP==VhdlDocGen::FUNCTION || m_sharedState->currP==VhdlDocGen::PROCEDURE)
+        {
+          outlineParser()->addProto(s5.data(),s.data(),s1.data(),s2.data(),s3.data(),s4.data());
+        }
+        else
+        {
+          QCString i=s2+s3+s4;
+          if (m_sharedState->currP==VhdlDocGen::GENERIC && m_sharedState->param_sec==0)
+            outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,i.data(),s1.data(),Public);
+          else if(m_sharedState->parse_sec != GEN_SEC)
+            outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,i.data(),s1.data(),Public);
+        }
+        //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
+      } // if component
+      return it;
 assert(false);
 }
 
@@ -5657,8 +5656,8 @@ QCString VhdlParser::iteration_scheme() {QCString s;
       if (!hasError) {
       
 s.prepend("while ");
-   FlowChart::addFlowChart(FlowChart::WHILE_NO,0,s.data(),lab.data());
-   lab="";
+   FlowChart::addFlowChart(FlowChart::WHILE_NO,0,s.data(),m_sharedState->lab.data());
+   m_sharedState->lab="";
   return s;
       }
       
@@ -5674,9 +5673,9 @@ s.prepend("while ");
       }
       if (!hasError) {
       
-QCString q=lab+" for "+s;
-    FlowChart::addFlowChart(FlowChart::FOR_NO,0,q.data(),lab.data());
-    lab="";
+QCString q=m_sharedState->lab+" for "+s;
+    FlowChart::addFlowChart(FlowChart::FOR_NO,0,q.data(),m_sharedState->lab.data());
+    m_sharedState->lab="";
     return q;
       }
       
@@ -5717,9 +5716,9 @@ QCString VhdlParser::library_clause() {QCString s;if (!hasError) {
     
     }
     
-if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
+if ( m_sharedState->parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
                    {
-                           addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
+                           outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
                    }
                    QCString s1="library "+s;
                    return s1;
@@ -6469,7 +6468,7 @@ QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;i
     
 if(t) s+=":";
    FlowChart::addFlowChart(FlowChart::NEXT_NO,"next ",s2.data(),s1.data());
-    lab.resize(0);
+    m_sharedState->lab.resize(0);
   if(t1) s2.prepend("when ");
   return s+s1+s2+";";
 assert(false);
@@ -6694,9 +6693,9 @@ void VhdlParser::package_body() {QCString s;if (!hasError) {
     }
     if (!hasError) {
     
-lastCompound=current.get();
+m_sharedState->lastCompound=m_sharedState->current;
                         s.prepend("_");
-                        addVhdlType(s,getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
+                        outlineParser()->addVhdlType(s,outlineParser()->getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
     }
     if (!hasError) {
     
@@ -6748,7 +6747,7 @@ lastCompound=current.get();
     jj_consume_token(SEMI_T);
     }
     
-lastCompound=0; genLabels.resize(0);
+m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
 }
 
 
@@ -6889,16 +6888,16 @@ void VhdlParser::package_declaration() {QCString s;if (!hasError) {
     }
     if (!hasError) {
     
-lastCompound=current.get();
-                          std::shared_ptr<Entry> clone=std::make_shared<Entry>(*current);
+m_sharedState->lastCompound=m_sharedState->current;
+                          std::shared_ptr<Entry> clone=std::make_shared<Entry>(*m_sharedState->current);
                           clone->section=Entry::NAMESPACE_SEC;
                           clone->spec=VhdlDocGen::PACKAGE;
                           clone->name=s;
-                          clone->startLine=getLine(PACKAGE_T);
-                          clone->bodyLine=getLine(PACKAGE_T);
+                          clone->startLine=outlineParser()->getLine(PACKAGE_T);
+                          clone->bodyLine=outlineParser()->getLine(PACKAGE_T);
                           clone->protection=Package;
-                          current_root->moveToSubEntryAndKeep(clone);
-                          addVhdlType(s,getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
+                          m_sharedState->current_root->moveToSubEntryAndKeep(clone);
+                          outlineParser()->addVhdlType(s,outlineParser()->getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
     }
     if (!hasError) {
     
@@ -6946,7 +6945,7 @@ lastCompound=current.get();
     jj_consume_token(SEMI_T);
     }
     
-lastEntity=0;lastCompound=0; genLabels.resize(0);
+m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
 }
 
 
@@ -7230,7 +7229,7 @@ QCString VhdlParser::physical_type_definition() {QCString s,s1,s2;if (!hasError)
     }
     if (!hasError) {
     
-addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);
+outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);
     }
     if (!hasError) {
     
@@ -7305,7 +7304,7 @@ void VhdlParser::port_clause() {if (!hasError) {
     jj_consume_token(SEMI_T);
     }
     
-currP=0;
+m_sharedState->currP=0;
 }
 
 
@@ -7791,9 +7790,9 @@ void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;if (!hasErro
     }
     if (!hasError) {
     
-currP=VhdlDocGen::PROCESS;
-               current->startLine=getLine();
-               current->bodyLine=getLine();
+m_sharedState->currP=VhdlDocGen::PROCESS;
+               m_sharedState->current->startLine=outlineParser()->getLine();
+               m_sharedState->current->bodyLine=outlineParser()->getLine();
     }
     if (!hasError) {
     
@@ -7922,20 +7921,20 @@ if (s2.data())
     }
     
 if(s.isEmpty())
-   currName=VhdlDocGen::getProcessNumber();
-   else
-   currName=s;
+            m_sharedState->currName=VhdlDocGen::getProcessNumber();
+          else
+            m_sharedState->currName=s;
 
-   current->name=currName;
-   tempEntry=current.get();
-   current->endBodyLine=getLine();
-   currP=0;
- if(tok)
-   s1=tok->image.data();
-  createFunction(currName,VhdlDocGen::PROCESS,s1.data());
-  createFlow();
-   currName="";
-   newEntry();
+          m_sharedState->current->name=m_sharedState->currName;
+          m_sharedState->tempEntry=m_sharedState->current;
+          m_sharedState->current->endBodyLine=outlineParser()->getLine();
+          m_sharedState->currP=0;
+          if(tok)
+            s1=tok->image.data();
+          outlineParser()->createFunction(m_sharedState->currName,VhdlDocGen::PROCESS,s1.data());
+          outlineParser()->createFlow();
+          m_sharedState->currName="";
+          outlineParser()->newEntry();
 }
 
 
@@ -8463,8 +8462,8 @@ QCString VhdlParser::secondary_unit_declaration() {QCString s,s1;if (!hasError)
     jj_consume_token(SEMI_T);
     }
     
-//printf("\n %s %s [%d]",s.data(),s1.data(),getLine());
-  addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
+//printf("\n %s %s [%d]",s.data(),s1.data(),outlineParser()->getLine());
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
 
   return s+"="+s1;
 assert(false);
@@ -9088,7 +9087,7 @@ void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;if (!
 if(tok)
       s3.prepend(":=");
      s4=s1+s2+s3;
-     addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
 }
 
 
@@ -9437,9 +9436,9 @@ if (s.data())
     jj_consume_token(SEMI_T);
     }
     
-tempEntry->endBodyLine=getLine(END_T);
-      createFlow();
-      currP=0;
+m_sharedState->tempEntry->endBodyLine=outlineParser()->getLine(END_T);
+      outlineParser()->createFlow();
+      m_sharedState->currP=0;
 }
 
 
@@ -9464,7 +9463,7 @@ void VhdlParser::subprogram_declaration() {
         }
         if (!hasError) {
         
-currP=0;
+m_sharedState->currP=0;
         }
         
         break;
@@ -9747,11 +9746,11 @@ void VhdlParser::subprogram_specification() {QCString s;Token *tok=0;Token *t;
       }
       if (!hasError) {
       
-currP=VhdlDocGen::PROCEDURE;
-              createFunction(s.data(),currP,0);
-              tempEntry=current.get();
-               current->startLine=getLine(PROCEDURE_T);
-               current->bodyLine=getLine(PROCEDURE_T);
+m_sharedState->currP=VhdlDocGen::PROCEDURE;
+   outlineParser()->createFunction(s.data(),m_sharedState->currP,0);
+   m_sharedState->tempEntry=m_sharedState->current;
+   m_sharedState->current->startLine=outlineParser()->getLine(PROCEDURE_T);
+   m_sharedState->current->bodyLine=outlineParser()->getLine(PROCEDURE_T);
       }
       if (!hasError) {
       
@@ -9762,7 +9761,7 @@ currP=VhdlDocGen::PROCEDURE;
         }
         if (!hasError) {
         
-param_sec=PARAM_SEC;
+m_sharedState->param_sec=PARAM_SEC;
         }
         if (!hasError) {
         
@@ -9770,7 +9769,7 @@ param_sec=PARAM_SEC;
         }
         if (!hasError) {
         
-param_sec=0;
+m_sharedState->param_sec=0;
         }
         if (!hasError) {
         
@@ -9812,7 +9811,7 @@ param_sec=0;
       }
       if (!hasError) {
       
-newEntry();
+outlineParser()->newEntry();
       }
       
       break;
@@ -9864,21 +9863,21 @@ newEntry();
       }
       if (!hasError) {
       
-currP=VhdlDocGen::FUNCTION;
-     if(tok)
-     createFunction(tok->image.c_str(),currP,s.data());
-     else
-     createFunction(0,currP,s.data());
-      tempEntry=current.get();
-      current->startLine=getLine(FUNCTION_T);
-      current->bodyLine=getLine(FUNCTION_T);
+m_sharedState->currP=VhdlDocGen::FUNCTION;
+   if(tok)
+     outlineParser()->createFunction(tok->image.c_str(),m_sharedState->currP,s.data());
+   else
+     outlineParser()->createFunction(0,m_sharedState->currP,s.data());
+   m_sharedState->tempEntry=m_sharedState->current;
+   m_sharedState->current->startLine=outlineParser()->getLine(FUNCTION_T);
+   m_sharedState->current->bodyLine=outlineParser()->getLine(FUNCTION_T);
       }
       if (!hasError) {
       
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case LPAREN_T:{if (!hasError) {
         
-param_sec=PARAM_SEC;
+m_sharedState->param_sec=PARAM_SEC;
         }
         if (!hasError) {
         
@@ -9894,7 +9893,7 @@ param_sec=PARAM_SEC;
         }
         if (!hasError) {
         
-param_sec=0;
+m_sharedState->param_sec=0;
         }
         
         break;
@@ -9914,9 +9913,9 @@ param_sec=0;
       }
       if (!hasError) {
       
-tempEntry=current.get();
-                current->type=s;
-                newEntry();
+m_sharedState->tempEntry=m_sharedState->current;
+                m_sharedState->current->type=s;
+                outlineParser()->newEntry();
       }
       
       break;
@@ -9990,7 +9989,7 @@ QCString VhdlParser::subtype_declaration() {QCString s,s1;if (!hasError) {
     jj_consume_token(SEMI_T);
     }
     
-addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
+outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
   return " subtype "+s+" is "+s1+";";
 assert(false);
 }
@@ -10417,9 +10416,9 @@ QCStringList ql1=QCStringList::split(",",s);
                    {
                      QCStringList ql=QCStringList::split(".",ql1[j]);
                      QCString it=ql[1];
-                     if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
+                     if ( m_sharedState->parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
                      {
-                       VhdlParser::addVhdlType(it.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),"_use_",Public);
+                       outlineParser()->addVhdlType(it.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),"_use_",Public);
                      }
                    }
                    s1="use "+s;
@@ -10552,25 +10551,26 @@ QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s
     }
     
 int spec;
-    if(t1)
-     s2.prepend(":=");
-    QCString val=" variable "+s+":"+s1+s2+";";
-    QCString it=s1;
-    if(tok != 0)
-    {
-     it.prepend(" shared ");
-     val.prepend(" shared");
-     spec=VhdlDocGen::SHAREDVARIABLE;
-     }
-     else
-     spec=VhdlDocGen::SHAREDVARIABLE;
+  if(t1)
+    s2.prepend(":=");
+  QCString val=" variable "+s+":"+s1+s2+";";
+  QCString it=s1;
+  if(tok != 0)
+  {
+    it.prepend(" shared ");
+    val.prepend(" shared");
+    spec=VhdlDocGen::SHAREDVARIABLE;
+  }
+  else
+    spec=VhdlDocGen::SHAREDVARIABLE;
 
-    if(t1){
-     it+=":=";
-     it+=s2;
-     }
-    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
-    return val;
+  if(t1)
+  {
+    it+=":=";
+    it+=s2;
+  }
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
+  return val;
 assert(false);
 }
 
@@ -10971,7 +10971,7 @@ QCString VhdlParser::protected_type_declaration() {if (!hasError) {
       }
       
     } catch ( ...) {
-error_skipto(END_T);
+outlineParser()->error_skipto(END_T);
     }
     }
     if (!hasError) {
@@ -11102,7 +11102,7 @@ void VhdlParser::context_declaration() {QCString s,s1;if (!hasError) {
     }
     if (!hasError) {
     
-parse_sec=CONTEXT_SEC;
+m_sharedState->parse_sec=CONTEXT_SEC;
     }
     if (!hasError) {
     
@@ -11165,8 +11165,8 @@ parse_sec=CONTEXT_SEC;
     jj_consume_token(SEMI_T);
     }
     
-parse_sec=0;
-                          addVhdlType(s.data(),getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
+m_sharedState->parse_sec=0;
+                          outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
 }
 
 
@@ -11259,7 +11259,7 @@ void VhdlParser::package_instantiation_declaration() {QCString s,s1,s2;if (!hasE
     }
     
 QCString q=" is new "+s1+s2;
-      addVhdlType(s.data(),getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
+      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
 }
 
 
@@ -11299,7 +11299,7 @@ QCString VhdlParser::interface_package_declaration() {QCString s,s1;if (!hasErro
     }
     }
     
-current->name=s;
+m_sharedState->current->name=s;
                             return "package "+s+" is new "+s1;
 assert(false);
 }
@@ -11350,7 +11350,7 @@ QCString VhdlParser::subprogram_instantiation_declaration() {QCString s,s1,s2;if
     }
     
 QCString q= " is new "+s1+s2;
-      addVhdlType(s.data(),getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
+      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
     return q;
 assert(false);
 }
@@ -11391,7 +11391,7 @@ void VhdlParser::gen_interface_list() {if (!hasError) {
     if (!hasError) {
     
 //int u=s_str.iLine;
-                          parse_sec=GEN_SEC;
+                          m_sharedState->parse_sec=GEN_SEC;
     }
     if (!hasError) {
     
@@ -11400,7 +11400,7 @@ void VhdlParser::gen_interface_list() {if (!hasError) {
     if (!hasError) {
     
 //  QCString vo=$3;
-                          parse_sec=0;
+                          m_sharedState->parse_sec=0;
     }
     if (!hasError) {
     
@@ -12608,8 +12608,8 @@ QCString VhdlParser::iproc() {QCString s,s1;if (!hasError) {
     s1 = param();
     }
     
-current->name=s;
-  return "procedure "+s+s1;
+m_sharedState->current->name=s;
+    return "procedure "+s+s1;
 assert(false);
 }
 
@@ -12707,23 +12707,23 @@ QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *
     }
     
 QCString q;
-      if(t) q=t->image.data();
-      if(t2) s3="<>";
-      if (!s3.isEmpty())
-      {
-        s3.prepend(" is ");
-      }
-     current->name=s;
-    if (parse_sec==GEN_SEC)
-                    {
-                      QCString ss=q+" function "+s1+" return "+s2+s3;
-                      int a=getLine(FUNCTION_T);
-                      int b=getLine(PROCEDURE_T);
-
-                      if (a>b) b=a;
-                      addVhdlType(current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public);
-                    }
-         currP=0;return "";
+   if(t) q=t->image.data();
+   if(t2) s3="<>";
+   if (!s3.isEmpty())
+   {
+     s3.prepend(" is ");
+   }
+   m_sharedState->current->name=s;
+   if (m_sharedState->parse_sec==GEN_SEC)
+   {
+     QCString ss=q+" function "+s1+" return "+s2+s3;
+     int a=outlineParser()->getLine(FUNCTION_T);
+     int b=outlineParser()->getLine(PROCEDURE_T);
+
+     if (a>b) b=a;
+     outlineParser()->addVhdlType(m_sharedState->current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public);
+   }
+   m_sharedState->currP=0;return "";
 assert(false);
 }
 
@@ -12745,7 +12745,7 @@ QCString VhdlParser::param() {QCString s,s1;Token *tok=0;if (!hasError) {
     }
     if (!hasError) {
     
-param_sec=PARAM_SEC;
+m_sharedState->param_sec=PARAM_SEC;
     }
     if (!hasError) {
     
@@ -12772,12 +12772,11 @@ param_sec=PARAM_SEC;
     }
     
 if(tok)
-                     {
-                      s = tok->image.data();
-
-                    }
-                      param_sec=0;
-                      return s+"("+s1+")";
+    {
+      s = tok->image.data();
+    }
+    m_sharedState->param_sec=0;
+    return s+"("+s1+")";
 assert(false);
 }
 
diff --git a/vhdlparser/VhdlParser.h b/vhdlparser/VhdlParser.h
index efdfe33..f2948a3 100644
--- a/vhdlparser/VhdlParser.h
+++ b/vhdlparser/VhdlParser.h
@@ -1506,13 +1506,6 @@ void parseInline();
  { jj_save(115, xla); }
   }
 
- inline bool jj_3_43()
- {
-    if (jj_done) return true;
-    if (jj_3R_93()) return true;
-    return false;
-  }
-
  inline bool jj_3R_139()
  {
     if (jj_done) return true;
@@ -1536,6 +1529,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_197()
+ {
+    if (jj_done) return true;
+    if (jj_3R_346()) return true;
+    return false;
+  }
+
  inline bool jj_3R_367()
  {
     if (jj_done) return true;
@@ -1556,13 +1556,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_197()
- {
-    if (jj_done) return true;
-    if (jj_3R_346()) return true;
-    return false;
-  }
-
  inline bool jj_3R_400()
  {
     if (jj_done) return true;
@@ -1727,25 +1720,18 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_38()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(BASIC_IDENTIFIER)) return true;
-    if (jj_scan_token(DOT_T)) return true;
-    return false;
-  }
-
- inline bool jj_3R_625()
+ inline bool jj_3R_696()
  {
     if (jj_done) return true;
     if (jj_3R_69()) return true;
     return false;
   }
 
- inline bool jj_3R_696()
+ inline bool jj_3_38()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
+    if (jj_scan_token(BASIC_IDENTIFIER)) return true;
+    if (jj_scan_token(DOT_T)) return true;
     return false;
   }
 
@@ -1763,6 +1749,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_625()
+ {
+    if (jj_done) return true;
+    if (jj_3R_69()) return true;
+    return false;
+  }
+
  inline bool jj_3R_331()
  {
     if (jj_done) return true;
@@ -1785,6 +1778,19 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_426()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(IS_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_696()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(145)) return true;
+    }
+    return false;
+  }
+
  inline bool jj_3R_328()
  {
     if (jj_done) return true;
@@ -1806,19 +1812,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_426()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(IS_T)) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_696()) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(145)) return true;
-    }
-    return false;
-  }
-
  inline bool jj_3R_173()
  {
     if (jj_done) return true;
@@ -1917,6 +1910,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_345()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(COMMA_T)) return true;
+    if (jj_3R_69()) return true;
+    return false;
+  }
+
  inline bool jj_3R_623()
  {
     if (jj_done) return true;
@@ -1936,11 +1937,22 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_345()
+ inline bool jj_3_116()
  {
     if (jj_done) return true;
-    if (jj_scan_token(COMMA_T)) return true;
-    if (jj_3R_69()) return true;
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(WHEN_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_424()
+ {
+    if (jj_done) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(77)) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_520()) jj_scanpos = xsp;
     return false;
   }
 
@@ -1988,22 +2000,18 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_424()
- {
-    if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(77)) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_520()) jj_scanpos = xsp;
-    return false;
-  }
-
- inline bool jj_3_116()
+ inline bool jj_3R_386()
  {
     if (jj_done) return true;
     if (jj_3R_58()) return true;
     if (jj_scan_token(WHEN_T)) return true;
+    if (jj_3R_85()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(134)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(137)) return true;
+    }
     return false;
   }
 
@@ -2041,28 +2049,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_386()
- {
-    if (jj_done) return true;
-    if (jj_3R_58()) return true;
-    if (jj_scan_token(WHEN_T)) return true;
-    if (jj_3R_85()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(134)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(137)) return true;
-    }
-    return false;
-  }
-
- inline bool jj_3R_446()
- {
-    if (jj_done) return true;
-    if (jj_3R_529()) return true;
-    return false;
-  }
-
  inline bool jj_3R_530()
  {
     if (jj_done) return true;
@@ -2071,16 +2057,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_65()
+ inline bool jj_3R_305()
  {
     if (jj_done) return true;
-    if (jj_scan_token(GROUP_T)) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(IS_T)) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_474()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_384()) return true;
     return false;
   }
 
@@ -2092,13 +2072,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_305()
- {
-    if (jj_done) return true;
-    if (jj_3R_384()) return true;
-    return false;
-  }
-
  inline bool jj_3R_425()
  {
     if (jj_done) return true;
@@ -2111,6 +2084,19 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_65()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(GROUP_T)) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(IS_T)) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_474()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
+    if (jj_scan_token(SEMI_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_344()
  {
     if (jj_done) return true;
@@ -2141,6 +2127,15 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_343()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(PROCEDURE_T)) return true;
+    if (jj_3R_69()) return true;
+    if (jj_3R_424()) return true;
+    return false;
+  }
+
  inline bool jj_3R_475()
  {
     if (jj_done) return true;
@@ -2153,20 +2148,29 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_304()
+ inline bool jj_3R_194()
  {
     if (jj_done) return true;
-    if (jj_3R_58()) return true;
-    if (jj_3R_385()) return true;
+    if (jj_3R_344()) return true;
     return false;
   }
 
- inline bool jj_3R_343()
+ inline bool jj_3R_193()
  {
     if (jj_done) return true;
-    if (jj_scan_token(PROCEDURE_T)) return true;
-    if (jj_3R_69()) return true;
-    if (jj_3R_424()) return true;
+    if (jj_3R_343()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_89()
+ {
+    if (jj_done) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_193()) {
+    jj_scanpos = xsp;
+    if (jj_3R_194()) return true;
+    }
     return false;
   }
 
@@ -2196,10 +2200,14 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_194()
+ inline bool jj_3R_476()
  {
     if (jj_done) return true;
-    if (jj_3R_344()) return true;
+    if (jj_scan_token(ELSE_T)) return true;
+    if (jj_3R_58()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_546()) jj_scanpos = xsp;
     return false;
   }
 
@@ -2214,43 +2222,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_193()
- {
-    if (jj_done) return true;
-    if (jj_3R_343()) return true;
-    return false;
-  }
-
- inline bool jj_3R_89()
- {
-    if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_193()) {
-    jj_scanpos = xsp;
-    if (jj_3R_194()) return true;
-    }
-    return false;
-  }
-
- inline bool jj_3R_170()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    return false;
-  }
-
- inline bool jj_3R_476()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(ELSE_T)) return true;
-    if (jj_3R_58()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_546()) jj_scanpos = xsp;
-    return false;
-  }
-
  inline bool jj_3R_385()
  {
     if (jj_done) return true;
@@ -2263,21 +2234,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_158()
- {
-    if (jj_done) return true;
-    if (jj_3R_313()) return true;
-    return false;
-  }
-
- inline bool jj_3R_66()
+ inline bool jj_3R_170()
  {
     if (jj_done) return true;
-    if (jj_scan_token(GENERIC_T)) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_158()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_69()) return true;
     return false;
   }
 
@@ -2293,18 +2253,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_447()
- {
-    if (jj_done) return true;
-    if (jj_3R_405()) return true;
-    return false;
-  }
-
- inline bool jj_3R_322()
+ inline bool jj_3R_158()
  {
     if (jj_done) return true;
-    if (jj_scan_token(IF_T)) return true;
-    if (jj_3R_79()) return true;
+    if (jj_3R_313()) return true;
     return false;
   }
 
@@ -2323,23 +2275,29 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_168()
+ inline bool jj_3R_66()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_321()) {
-    jj_scanpos = xsp;
-    if (jj_3R_322()) return true;
-    }
+    if (jj_scan_token(GENERIC_T)) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_158()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
- inline bool jj_3R_321()
+ inline bool jj_3R_447()
  {
     if (jj_done) return true;
-    if (jj_scan_token(FOR_T)) return true;
-    if (jj_3R_408()) return true;
+    if (jj_3R_405()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_322()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(IF_T)) return true;
+    if (jj_3R_79()) return true;
     return false;
   }
 
@@ -2362,35 +2320,23 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_303()
- {
-    if (jj_done) return true;
-    if (jj_3R_384()) return true;
-    return false;
-  }
-
- inline bool jj_3_112()
+ inline bool jj_3R_168()
  {
     if (jj_done) return true;
-    if (jj_3R_142()) return true;
-    if (jj_scan_token(DOT_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_321()) {
+    jj_scanpos = xsp;
+    if (jj_3R_322()) return true;
+    }
     return false;
   }
 
- inline bool jj_3R_74()
+ inline bool jj_3R_321()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    if (jj_3R_168()) return true;
-    if (jj_scan_token(GENERATE_T)) return true;
-    if (jj_3R_169()) return true;
-    if (jj_scan_token(END_T)) return true;
-    if (jj_scan_token(GENERATE_T)) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_170()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_scan_token(FOR_T)) return true;
+    if (jj_3R_408()) return true;
     return false;
   }
 
@@ -2412,16 +2358,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_104()
- {
-    if (jj_done) return true;
-    if (jj_3R_59()) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_226()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    return false;
-  }
-
  inline bool jj_3_115()
  {
     if (jj_done) return true;
@@ -2446,11 +2382,20 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_301()
+ inline bool jj_3R_74()
  {
     if (jj_done) return true;
-    if (jj_3R_142()) return true;
-    if (jj_scan_token(DOT_T)) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_168()) return true;
+    if (jj_scan_token(GENERATE_T)) return true;
+    if (jj_3R_169()) return true;
+    if (jj_scan_token(END_T)) return true;
+    if (jj_scan_token(GENERATE_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_170()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
@@ -2461,14 +2406,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_575()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(WHEN_T)) return true;
-    if (jj_3R_58()) return true;
-    return false;
-  }
-
  inline bool jj_3R_686()
  {
     if (jj_done) return true;
@@ -2488,6 +2425,32 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_104()
+ {
+    if (jj_done) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_226()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3_112()
+ {
+    if (jj_done) return true;
+    if (jj_3R_142()) return true;
+    if (jj_scan_token(DOT_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_575()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(WHEN_T)) return true;
+    if (jj_3R_58()) return true;
+    return false;
+  }
+
  inline bool jj_3_114()
  {
     if (jj_done) return true;
@@ -2510,17 +2473,33 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_444()
+ inline bool jj_3R_303()
  {
     if (jj_done) return true;
-    if (jj_3R_405()) return true;
+    if (jj_3R_384()) return true;
     return false;
   }
 
- inline bool jj_3R_463()
+ inline bool jj_3R_301()
  {
     if (jj_done) return true;
-    if (jj_3R_534()) return true;
+    if (jj_3R_142()) return true;
+    if (jj_scan_token(DOT_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_304()
+ {
+    if (jj_done) return true;
+    if (jj_3R_58()) return true;
+    if (jj_3R_385()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_446()
+ {
+    if (jj_done) return true;
+    if (jj_3R_529()) return true;
     return false;
   }
 
@@ -2550,6 +2529,20 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_463()
+ {
+    if (jj_done) return true;
+    if (jj_3R_534()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_444()
+ {
+    if (jj_done) return true;
+    if (jj_3R_405()) return true;
+    return false;
+  }
+
  inline bool jj_3R_143()
  {
     if (jj_done) return true;
@@ -2567,6 +2560,17 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_529()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(ELSE_T)) return true;
+    if (jj_3R_58()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_575()) jj_scanpos = xsp;
+    return false;
+  }
+
  inline bool jj_3R_156()
  {
     if (jj_done) return true;
@@ -2576,21 +2580,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_529()
+ inline bool jj_3_113()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ELSE_T)) return true;
-    if (jj_3R_58()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_575()) jj_scanpos = xsp;
+    if (jj_3R_143()) return true;
     return false;
   }
 
- inline bool jj_3_113()
+ inline bool jj_3R_324()
  {
     if (jj_done) return true;
-    if (jj_3R_143()) return true;
+    if (jj_3R_410()) return true;
     return false;
   }
 
@@ -2605,13 +2605,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_324()
- {
-    if (jj_done) return true;
-    if (jj_3R_410()) return true;
-    return false;
-  }
-
  inline bool jj_3R_368()
  {
     if (jj_done) return true;
@@ -2629,16 +2622,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_63()
- {
-    if (jj_done) return true;
-    if (jj_3R_59()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_156()) jj_scanpos = xsp;
-    return false;
-  }
-
  inline bool jj_3R_269()
  {
     if (jj_done) return true;
@@ -2646,10 +2629,13 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_570()
+ inline bool jj_3R_63()
  {
     if (jj_done) return true;
-    if (jj_3R_313()) return true;
+    if (jj_3R_59()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_156()) jj_scanpos = xsp;
     return false;
   }
 
@@ -2672,6 +2658,21 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_570()
+ {
+    if (jj_done) return true;
+    if (jj_3R_313()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_555()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(AT_T)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
  inline bool jj_3R_398()
  {
     if (jj_done) return true;
@@ -2679,6 +2680,15 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_302()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_312()
  {
     if (jj_done) return true;
@@ -2698,6 +2708,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3_111()
+ {
+    if (jj_done) return true;
+    if (jj_3R_141()) return true;
+    return false;
+  }
+
  inline bool jj_3R_141()
  {
     if (jj_done) return true;
@@ -2711,24 +2728,7 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_555()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(AT_T)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
- inline bool jj_3R_302()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_58()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    return false;
-  }
-
- inline bool jj_3_111()
+ inline bool jj_3R_612()
  {
     if (jj_done) return true;
     if (jj_3R_141()) return true;
@@ -2744,10 +2744,13 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_612()
+ inline bool jj_3R_142()
  {
     if (jj_done) return true;
-    if (jj_3R_141()) return true;
+    if (jj_3R_69()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_302()) jj_scanpos = xsp;
     return false;
   }
 
@@ -2770,16 +2773,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_142()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_302()) jj_scanpos = xsp;
-    return false;
-  }
-
  inline bool jj_3R_640()
  {
     if (jj_done) return true;
@@ -2788,13 +2781,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_581()
- {
-    if (jj_done) return true;
-    if (jj_3R_58()) return true;
-    return false;
-  }
-
  inline bool jj_3R_611()
  {
     if (jj_done) return true;
@@ -2807,6 +2793,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_581()
+ {
+    if (jj_done) return true;
+    if (jj_3R_58()) return true;
+    return false;
+  }
+
  inline bool jj_3_110()
  {
     if (jj_done) return true;
@@ -2842,6 +2835,27 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_609()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(DOT_T)) return true;
+    if (jj_3R_141()) return true;
+    if (jj_3R_69()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_553()
+ {
+    if (jj_done) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_609()) {
+    jj_scanpos = xsp;
+    if (jj_3R_610()) return true;
+    }
+    return false;
+  }
+
  inline bool jj_3R_376()
  {
     if (jj_done) return true;
@@ -2863,32 +2877,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_609()
+ inline bool jj_3R_489()
  {
     if (jj_done) return true;
-    if (jj_scan_token(DOT_T)) return true;
-    if (jj_3R_141()) return true;
-    if (jj_3R_69()) return true;
+    if (jj_3R_555()) return true;
     return false;
   }
 
- inline bool jj_3R_553()
+ inline bool jj_3R_284()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_609()) {
-    jj_scanpos = xsp;
-    if (jj_3R_610()) return true;
-    }
+    if (jj_scan_token(NOT_T)) return true;
+    if (jj_3R_370()) return true;
     return false;
   }
 
- inline bool jj_3R_284()
+ inline bool jj_3R_488()
  {
     if (jj_done) return true;
-    if (jj_scan_token(NOT_T)) return true;
-    if (jj_3R_370()) return true;
+    if (jj_3R_554()) return true;
     return false;
   }
 
@@ -2900,17 +2907,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_489()
+ inline bool jj_3R_396()
  {
     if (jj_done) return true;
-    if (jj_3R_555()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_487()) {
+    jj_scanpos = xsp;
+    if (jj_3R_488()) {
+    jj_scanpos = xsp;
+    if (jj_3R_489()) return true;
+    }
+    }
     return false;
   }
 
- inline bool jj_3R_488()
+ inline bool jj_3R_487()
  {
     if (jj_done) return true;
-    if (jj_3R_554()) return true;
+    if (jj_3R_553()) return true;
     return false;
   }
 
@@ -2939,32 +2954,24 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_396()
+ inline bool jj_3_107()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_487()) {
-    jj_scanpos = xsp;
-    if (jj_3R_488()) {
-    jj_scanpos = xsp;
-    if (jj_3R_489()) return true;
-    }
-    }
+    if (jj_3R_138()) return true;
     return false;
   }
 
- inline bool jj_3R_487()
+ inline bool jj_3R_486()
  {
     if (jj_done) return true;
-    if (jj_3R_553()) return true;
+    if (jj_scan_token(VARIABLE_T)) return true;
     return false;
   }
 
- inline bool jj_3_107()
+ inline bool jj_3R_485()
  {
     if (jj_done) return true;
-    if (jj_3R_138()) return true;
+    if (jj_scan_token(SIGNAL_T)) return true;
     return false;
   }
 
@@ -2976,25 +2983,33 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_486()
+ inline bool jj_3R_146()
  {
     if (jj_done) return true;
-    if (jj_scan_token(VARIABLE_T)) return true;
+    if (jj_3R_309()) return true;
+    if (jj_3R_145()) return true;
     return false;
   }
 
- inline bool jj_3R_146()
+ inline bool jj_3R_395()
  {
     if (jj_done) return true;
-    if (jj_3R_309()) return true;
-    if (jj_3R_145()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_484()) {
+    jj_scanpos = xsp;
+    if (jj_3R_485()) {
+    jj_scanpos = xsp;
+    if (jj_3R_486()) return true;
+    }
+    }
     return false;
   }
 
- inline bool jj_3R_485()
+ inline bool jj_3R_484()
  {
     if (jj_done) return true;
-    if (jj_scan_token(SIGNAL_T)) return true;
+    if (jj_scan_token(CONSTANT_T)) return true;
     return false;
   }
 
@@ -3019,25 +3034,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_395()
+ inline bool jj_3_109()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_484()) {
-    jj_scanpos = xsp;
-    if (jj_3R_485()) {
-    jj_scanpos = xsp;
-    if (jj_3R_486()) return true;
-    }
-    }
+    if (jj_3R_140()) return true;
     return false;
   }
 
- inline bool jj_3R_484()
+ inline bool jj_3R_275()
  {
     if (jj_done) return true;
-    if (jj_scan_token(CONSTANT_T)) return true;
+    if (jj_3R_132()) return true;
     return false;
   }
 
@@ -3055,20 +3062,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_109()
- {
-    if (jj_done) return true;
-    if (jj_3R_140()) return true;
-    return false;
-  }
-
- inline bool jj_3R_275()
- {
-    if (jj_done) return true;
-    if (jj_3R_132()) return true;
-    return false;
-  }
-
  inline bool jj_3R_309()
  {
     if (jj_done) return true;
@@ -3112,18 +3105,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_58()
- {
-    if (jj_done) return true;
-    if (jj_3R_145()) return true;
-    Token * xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_146()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
  inline bool jj_3R_409()
  {
     if (jj_done) return true;
@@ -3143,6 +3124,18 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_58()
+ {
+    if (jj_done) return true;
+    if (jj_3R_145()) return true;
+    Token * xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_146()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
  inline bool jj_3R_169()
  {
     if (jj_done) return true;
@@ -3171,33 +3164,33 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_265()
+ inline bool jj_3R_235()
  {
     if (jj_done) return true;
-    if (jj_scan_token(WHEN_T)) return true;
-    if (jj_3R_79()) return true;
+    if (jj_3R_132()) return true;
     return false;
   }
 
- inline bool jj_3R_235()
+ inline bool jj_3_108()
  {
     if (jj_done) return true;
-    if (jj_3R_132()) return true;
+    if (jj_3R_139()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
- inline bool jj_3R_263()
+ inline bool jj_3R_265()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_scan_token(WHEN_T)) return true;
+    if (jj_3R_79()) return true;
     return false;
   }
 
- inline bool jj_3_108()
+ inline bool jj_3R_263()
  {
     if (jj_done) return true;
-    if (jj_3R_139()) return true;
+    if (jj_3R_69()) return true;
     if (jj_scan_token(COLON_T)) return true;
     return false;
   }
@@ -3228,6 +3221,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_641()
+ {
+    if (jj_done) return true;
+    if (jj_3R_132()) return true;
+    return false;
+  }
+
  inline bool jj_3R_688()
  {
     if (jj_done) return true;
@@ -3242,13 +3242,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_641()
- {
-    if (jj_done) return true;
-    if (jj_3R_132()) return true;
-    return false;
-  }
-
  inline bool jj_3R_652()
  {
     if (jj_done) return true;
@@ -3262,13 +3255,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_208()
- {
-    if (jj_done) return true;
-    if (jj_3R_352()) return true;
-    return false;
-  }
-
  inline bool jj_3R_619()
  {
     if (jj_done) return true;
@@ -3281,6 +3267,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_208()
+ {
+    if (jj_done) return true;
+    if (jj_3R_352()) return true;
+    return false;
+  }
+
  inline bool jj_3R_207()
  {
     if (jj_done) return true;
@@ -3300,13 +3293,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_695()
- {
-    if (jj_done) return true;
-    if (jj_3R_352()) return true;
-    return false;
-  }
-
  inline bool jj_3R_561()
  {
     if (jj_done) return true;
@@ -3317,6 +3303,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_695()
+ {
+    if (jj_done) return true;
+    if (jj_3R_352()) return true;
+    return false;
+  }
+
  inline bool jj_3R_694()
  {
     if (jj_done) return true;
@@ -3401,6 +3394,22 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_130()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(FUNCTION_T)) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(IS_T)) return true;
+    if (jj_scan_token(NEW_T)) return true;
+    if (jj_3R_59()) return true;
+    if (jj_3R_234()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_275()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMI_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_638()
  {
     if (jj_done) return true;
@@ -3435,22 +3444,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_130()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(FUNCTION_T)) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(IS_T)) return true;
-    if (jj_scan_token(NEW_T)) return true;
-    if (jj_3R_59()) return true;
-    if (jj_3R_234()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_275()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMI_T)) return true;
-    return false;
-  }
-
  inline bool jj_3R_107()
  {
     if (jj_done) return true;
@@ -3560,17 +3553,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_606()
+ inline bool jj_3R_719()
  {
     if (jj_done) return true;
-    if (jj_scan_token(BOX_T)) return true;
+    if (jj_3R_379()) return true;
     return false;
   }
 
- inline bool jj_3R_719()
+ inline bool jj_3R_606()
  {
     if (jj_done) return true;
-    if (jj_3R_379()) return true;
+    if (jj_scan_token(BOX_T)) return true;
     return false;
   }
 
@@ -3618,18 +3611,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_474()
- {
-    if (jj_done) return true;
-    if (jj_3R_542()) return true;
-    Token * xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_543()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
  inline bool jj_3R_658()
  {
     if (jj_done) return true;
@@ -3643,20 +3624,22 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_692()
+ inline bool jj_3R_474()
  {
     if (jj_done) return true;
-    if (jj_3R_702()) return true;
+    if (jj_3R_542()) return true;
+    Token * xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_543()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
- inline bool jj_3R_542()
+ inline bool jj_3R_692()
  {
     if (jj_done) return true;
-    if (jj_3R_540()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_606()) jj_scanpos = xsp;
+    if (jj_3R_702()) return true;
     return false;
   }
 
@@ -3678,19 +3661,13 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_620()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    return false;
-  }
-
- inline bool jj_3R_602()
+ inline bool jj_3R_542()
  {
     if (jj_done) return true;
-    if (jj_scan_token(FILE_T)) return true;
+    if (jj_3R_540()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_606()) jj_scanpos = xsp;
     return false;
   }
 
@@ -3701,24 +3678,19 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_601()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(GROUP_T)) return true;
-    return false;
-  }
-
- inline bool jj_3R_600()
+ inline bool jj_3R_620()
  {
     if (jj_done) return true;
-    if (jj_scan_token(UNITS_T)) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
     return false;
   }
 
- inline bool jj_3R_599()
+ inline bool jj_3R_602()
  {
     if (jj_done) return true;
-    if (jj_scan_token(LITERAL_T)) return true;
+    if (jj_scan_token(FILE_T)) return true;
     return false;
   }
 
@@ -3736,10 +3708,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_598()
+ inline bool jj_3R_601()
  {
     if (jj_done) return true;
-    if (jj_scan_token(LABEL_T)) return true;
+    if (jj_scan_token(GROUP_T)) return true;
     return false;
   }
 
@@ -3750,17 +3722,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_597()
+ inline bool jj_3R_600()
  {
     if (jj_done) return true;
-    if (jj_scan_token(COMPONENT_T)) return true;
+    if (jj_scan_token(UNITS_T)) return true;
     return false;
   }
 
- inline bool jj_3R_596()
+ inline bool jj_3R_599()
  {
     if (jj_done) return true;
-    if (jj_scan_token(VARIABLE_T)) return true;
+    if (jj_scan_token(LITERAL_T)) return true;
     return false;
   }
 
@@ -3771,17 +3743,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_595()
+ inline bool jj_3R_598()
  {
     if (jj_done) return true;
-    if (jj_scan_token(SIGNAL_T)) return true;
+    if (jj_scan_token(LABEL_T)) return true;
     return false;
   }
 
- inline bool jj_3R_594()
+ inline bool jj_3R_597()
  {
     if (jj_done) return true;
-    if (jj_scan_token(CONSTANT_T)) return true;
+    if (jj_scan_token(COMPONENT_T)) return true;
     return false;
   }
 
@@ -3792,10 +3764,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_593()
+ inline bool jj_3R_596()
  {
     if (jj_done) return true;
-    if (jj_scan_token(SUBTYPE_T)) return true;
+    if (jj_scan_token(VARIABLE_T)) return true;
     return false;
   }
 
@@ -3806,10 +3778,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_592()
+ inline bool jj_3R_595()
  {
     if (jj_done) return true;
-    if (jj_scan_token(TYPE_T)) return true;
+    if (jj_scan_token(SIGNAL_T)) return true;
     return false;
   }
 
@@ -3820,10 +3792,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_591()
+ inline bool jj_3R_594()
  {
     if (jj_done) return true;
-    if (jj_scan_token(PACKAGE_T)) return true;
+    if (jj_scan_token(CONSTANT_T)) return true;
     return false;
   }
 
@@ -3834,10 +3806,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_590()
+ inline bool jj_3R_593()
  {
     if (jj_done) return true;
-    if (jj_scan_token(FUNCTION_T)) return true;
+    if (jj_scan_token(SUBTYPE_T)) return true;
     return false;
   }
 
@@ -3848,10 +3820,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_589()
+ inline bool jj_3R_592()
  {
     if (jj_done) return true;
-    if (jj_scan_token(PROCEDURE_T)) return true;
+    if (jj_scan_token(TYPE_T)) return true;
     return false;
   }
 
@@ -3862,10 +3834,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_588()
+ inline bool jj_3R_591()
  {
     if (jj_done) return true;
-    if (jj_scan_token(CONFIGURATION_T)) return true;
+    if (jj_scan_token(PACKAGE_T)) return true;
     return false;
   }
 
@@ -3876,10 +3848,24 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_587()
+ inline bool jj_3R_590()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ARCHITECTURE_T)) return true;
+    if (jj_scan_token(FUNCTION_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_589()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(PROCEDURE_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_588()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(CONFIGURATION_T)) return true;
     return false;
   }
 
@@ -3935,6 +3921,20 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_587()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(ARCHITECTURE_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_252()
+ {
+    if (jj_done) return true;
+    if (jj_3R_364()) return true;
+    return false;
+  }
+
  inline bool jj_3R_586()
  {
     if (jj_done) return true;
@@ -3999,13 +3999,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_252()
- {
-    if (jj_done) return true;
-    if (jj_3R_364()) return true;
-    return false;
-  }
-
  inline bool jj_3R_564()
  {
     if (jj_done) return true;
@@ -4021,6 +4014,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_528()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(AFTER_T)) return true;
+    if (jj_3R_58()) return true;
+    return false;
+  }
+
  inline bool jj_3R_562()
  {
     if (jj_done) return true;
@@ -4032,14 +4033,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_528()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(AFTER_T)) return true;
-    if (jj_3R_58()) return true;
-    return false;
-  }
-
  inline bool jj_3R_506()
  {
     if (jj_done) return true;
@@ -4096,13 +4089,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_30()
- {
-    if (jj_done) return true;
-    if (jj_3R_84()) return true;
-    return false;
-  }
-
  inline bool jj_3R_445()
  {
     if (jj_done) return true;
@@ -4113,28 +4099,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_29()
+ inline bool jj_3_30()
  {
     if (jj_done) return true;
-    if (jj_3R_83()) return true;
+    if (jj_3R_84()) return true;
     return false;
   }
 
- inline bool jj_3R_359()
+ inline bool jj_3_29()
  {
     if (jj_done) return true;
-    if (jj_3R_85()) return true;
-    if (jj_scan_token(ARROW_T)) return true;
+    if (jj_3R_83()) return true;
     return false;
   }
 
- inline bool jj_3R_236()
+ inline bool jj_3R_359()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_359()) jj_scanpos = xsp;
-    if (jj_3R_58()) return true;
+    if (jj_3R_85()) return true;
+    if (jj_scan_token(ARROW_T)) return true;
     return false;
   }
 
@@ -4145,10 +4128,13 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_160()
+ inline bool jj_3R_236()
  {
     if (jj_done) return true;
-    if (jj_3R_84()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_359()) jj_scanpos = xsp;
+    if (jj_3R_58()) return true;
     return false;
   }
 
@@ -4176,6 +4162,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_160()
+ {
+    if (jj_done) return true;
+    if (jj_3R_84()) return true;
+    return false;
+  }
+
  inline bool jj_3R_159()
  {
     if (jj_done) return true;
@@ -4203,15 +4196,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_471()
- {
-    if (jj_done) return true;
-    if (jj_3R_541()) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
  inline bool jj_3R_117()
  {
     if (jj_done) return true;
@@ -4229,6 +4213,15 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_471()
+ {
+    if (jj_done) return true;
+    if (jj_3R_541()) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
  inline bool jj_3R_381()
  {
     if (jj_done) return true;
@@ -4255,6 +4248,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_155()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(COMMA_T)) return true;
+    if (jj_3R_154()) return true;
+    return false;
+  }
+
  inline bool jj_3R_109()
  {
     if (jj_done) return true;
@@ -4274,14 +4275,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_155()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(COMMA_T)) return true;
-    if (jj_3R_154()) return true;
-    return false;
-  }
-
  inline bool jj_3R_569()
  {
     if (jj_done) return true;
@@ -4332,6 +4325,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_473()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(COMMA_T)) return true;
+    if (jj_3R_472()) return true;
+    return false;
+  }
+
  inline bool jj_3R_559()
  {
     if (jj_done) return true;
@@ -4340,11 +4341,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_473()
+ inline bool jj_3R_440()
  {
     if (jj_done) return true;
-    if (jj_scan_token(COMMA_T)) return true;
-    if (jj_3R_472()) return true;
+    if (jj_3R_527()) return true;
     return false;
   }
 
@@ -4358,13 +4358,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_440()
- {
-    if (jj_done) return true;
-    if (jj_3R_527()) return true;
-    return false;
-  }
-
  inline bool jj_3R_405()
  {
     if (jj_done) return true;
@@ -4488,20 +4481,20 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_704()
+ inline bool jj_3R_157()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ARRAY_T)) return true;
-    if (jj_3R_82()) return true;
-    if (jj_scan_token(OF_T)) return true;
-    if (jj_3R_84()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
- inline bool jj_3R_157()
+ inline bool jj_3R_704()
  {
     if (jj_done) return true;
-    if (jj_3R_59()) return true;
+    if (jj_scan_token(ARRAY_T)) return true;
+    if (jj_3R_82()) return true;
+    if (jj_scan_token(OF_T)) return true;
+    if (jj_3R_84()) return true;
     return false;
   }
 
@@ -4526,31 +4519,31 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_373()
+ inline bool jj_3R_635()
  {
     if (jj_done) return true;
-    if (jj_scan_token(CONSTANT_T)) return true;
-    if (jj_3R_196()) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    if (jj_3R_84()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_459()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_656()) return true;
     return false;
   }
 
- inline bool jj_3R_635()
+ inline bool jj_3R_634()
  {
     if (jj_done) return true;
-    if (jj_3R_656()) return true;
+    if (jj_3R_655()) return true;
     return false;
   }
 
- inline bool jj_3R_634()
+ inline bool jj_3R_373()
  {
     if (jj_done) return true;
-    if (jj_3R_655()) return true;
+    if (jj_scan_token(CONSTANT_T)) return true;
+    if (jj_3R_196()) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_84()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_459()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
@@ -4592,27 +4585,27 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_380()
+ inline bool jj_3_99()
  {
     if (jj_done) return true;
-    if (jj_scan_token(FOR_T)) return true;
-    if (jj_3R_177()) return true;
-    if (jj_3R_332()) return true;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_133()) return true;
     return false;
   }
 
- inline bool jj_3_99()
+ inline bool jj_3R_458()
  {
     if (jj_done) return true;
-    if (jj_3R_133()) return true;
+    if (jj_3R_532()) return true;
     return false;
   }
 
- inline bool jj_3R_458()
+ inline bool jj_3R_380()
  {
     if (jj_done) return true;
-    if (jj_3R_532()) return true;
+    if (jj_scan_token(FOR_T)) return true;
+    if (jj_3R_177()) return true;
+    if (jj_3R_332()) return true;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
@@ -4642,6 +4635,16 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_105()
+ {
+    if (jj_done) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_566()
  {
     if (jj_done) return true;
@@ -4661,16 +4664,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_105()
- {
-    if (jj_done) return true;
-    if (jj_3R_59()) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_58()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    return false;
-  }
-
  inline bool jj_3_101()
  {
     if (jj_done) return true;
@@ -4753,34 +4746,34 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_25()
+ inline bool jj_3R_217()
  {
     if (jj_done) return true;
-    if (jj_scan_token(WHEN_T)) return true;
-    if (jj_3R_79()) return true;
-    if (jj_scan_token(ELSE_T)) return true;
+    if (jj_3R_310()) return true;
     return false;
   }
 
- inline bool jj_3R_350()
+ inline bool jj_3R_216()
  {
     if (jj_done) return true;
-    if (jj_scan_token(CONFIGURATION_T)) return true;
-    if (jj_3R_69()) return true;
+    if (jj_3R_352()) return true;
     return false;
   }
 
- inline bool jj_3R_217()
+ inline bool jj_3_25()
  {
     if (jj_done) return true;
-    if (jj_3R_310()) return true;
+    if (jj_scan_token(WHEN_T)) return true;
+    if (jj_3R_79()) return true;
+    if (jj_scan_token(ELSE_T)) return true;
     return false;
   }
 
- inline bool jj_3R_216()
+ inline bool jj_3R_350()
  {
     if (jj_done) return true;
-    if (jj_3R_352()) return true;
+    if (jj_scan_token(CONFIGURATION_T)) return true;
+    if (jj_3R_69()) return true;
     return false;
   }
 
@@ -4809,14 +4802,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_320()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(WHEN_T)) return true;
-    if (jj_3R_79()) return true;
-    return false;
-  }
-
  inline bool jj_3R_183()
  {
     if (jj_done) return true;
@@ -4824,13 +4809,11 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_319()
+ inline bool jj_3R_320()
  {
     if (jj_done) return true;
     if (jj_scan_token(WHEN_T)) return true;
     if (jj_3R_79()) return true;
-    if (jj_scan_token(ELSE_T)) return true;
-    if (jj_3R_318()) return true;
     return false;
   }
 
@@ -4846,6 +4829,16 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_319()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(WHEN_T)) return true;
+    if (jj_3R_79()) return true;
+    if (jj_scan_token(ELSE_T)) return true;
+    if (jj_3R_318()) return true;
+    return false;
+  }
+
  inline bool jj_3R_167()
  {
     if (jj_done) return true;
@@ -4860,17 +4853,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_71()
- {
-    if (jj_done) return true;
-    if (jj_3R_114()) return true;
-    if (jj_scan_token(LESSTHAN_T)) return true;
-    if (jj_3R_166()) return true;
-    if (jj_3R_167()) return true;
-    if (jj_scan_token(SEMI_T)) return true;
-    return false;
-  }
-
  inline bool jj_3R_372()
  {
     if (jj_done) return true;
@@ -4889,6 +4871,17 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_71()
+ {
+    if (jj_done) return true;
+    if (jj_3R_114()) return true;
+    if (jj_scan_token(LESSTHAN_T)) return true;
+    if (jj_3R_166()) return true;
+    if (jj_3R_167()) return true;
+    if (jj_scan_token(SEMI_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_572()
  {
     if (jj_done) return true;
@@ -4908,13 +4901,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_79()
- {
-    if (jj_done) return true;
-    if (jj_3R_58()) return true;
-    return false;
-  }
-
  inline bool jj_3R_524()
  {
     if (jj_done) return true;
@@ -4924,19 +4910,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_522()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_313()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
-    return false;
-  }
-
- inline bool jj_3_97()
+ inline bool jj_3R_79()
  {
     if (jj_done) return true;
-    if (jj_3R_132()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
@@ -4947,13 +4924,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_96()
- {
-    if (jj_done) return true;
-    if (jj_3R_131()) return true;
-    return false;
-  }
-
  inline bool jj_3_23()
  {
     if (jj_done) return true;
@@ -4980,11 +4950,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_75()
+ inline bool jj_3_97()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_132()) return true;
     return false;
   }
 
@@ -5003,6 +4972,30 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_75()
+ {
+    if (jj_done) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3_96()
+ {
+    if (jj_done) return true;
+    if (jj_3R_131()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_522()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_313()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
+    return false;
+  }
+
  inline bool jj_3_21()
  {
     if (jj_done) return true;
@@ -5088,13 +5081,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_500()
- {
-    if (jj_done) return true;
-    if (jj_3R_561()) return true;
-    return false;
-  }
-
  inline bool jj_3R_347()
  {
     if (jj_done) return true;
@@ -5123,17 +5109,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_499()
+ inline bool jj_3R_500()
  {
     if (jj_done) return true;
-    if (jj_3R_74()) return true;
+    if (jj_3R_561()) return true;
     return false;
   }
 
- inline bool jj_3R_498()
+ inline bool jj_3R_499()
  {
     if (jj_done) return true;
-    if (jj_3R_88()) return true;
+    if (jj_3R_74()) return true;
     return false;
   }
 
@@ -5149,6 +5135,31 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_498()
+ {
+    if (jj_done) return true;
+    if (jj_3R_88()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_630()
+ {
+    if (jj_done) return true;
+    if (jj_3R_653()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_571()
+ {
+    if (jj_done) return true;
+    Token * xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_630()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
  inline bool jj_3R_410()
  {
     if (jj_done) return true;
@@ -5189,13 +5200,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_630()
- {
-    if (jj_done) return true;
-    if (jj_3R_653()) return true;
-    return false;
-  }
-
  inline bool jj_3_17()
  {
     if (jj_done) return true;
@@ -5203,17 +5207,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_571()
- {
-    if (jj_done) return true;
-    Token * xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_630()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
  inline bool jj_3_94()
  {
     if (jj_done) return true;
@@ -5242,32 +5235,32 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_171()
+ inline bool jj_3_95()
  {
     if (jj_done) return true;
-    if (jj_3R_71()) return true;
+    if (jj_3R_65()) return true;
     return false;
   }
 
- inline bool jj_3_16()
+ inline bool jj_3R_673()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_379()) return true;
     return false;
   }
 
- inline bool jj_3_95()
+ inline bool jj_3R_171()
  {
     if (jj_done) return true;
-    if (jj_3R_65()) return true;
+    if (jj_3R_71()) return true;
     return false;
   }
 
- inline bool jj_3R_673()
+ inline bool jj_3_16()
  {
     if (jj_done) return true;
-    if (jj_3R_379()) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
@@ -5287,14 +5280,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_15()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    return false;
-  }
-
  inline bool jj_3R_672()
  {
     if (jj_done) return true;
@@ -5316,30 +5301,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_669()
+ inline bool jj_3_15()
  {
     if (jj_done) return true;
-    if (jj_3R_375()) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
- inline bool jj_3R_574()
+ inline bool jj_3R_669()
  {
     if (jj_done) return true;
-    if (jj_3R_521()) return true;
+    if (jj_3R_375()) return true;
     return false;
   }
 
- inline bool jj_3R_78()
+ inline bool jj_3R_574()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3_15()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(79)) jj_scanpos = xsp;
-    if (jj_3R_176()) return true;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_521()) return true;
     return false;
   }
 
@@ -5364,6 +5344,19 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_78()
+ {
+    if (jj_done) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3_15()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(79)) jj_scanpos = xsp;
+    if (jj_3R_176()) return true;
+    if (jj_scan_token(SEMI_T)) return true;
+    return false;
+  }
+
  inline bool jj_3_14()
  {
     if (jj_done) return true;
@@ -5386,19 +5379,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_87()
- {
-    if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3_14()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(79)) jj_scanpos = xsp;
-    if (jj_3R_187()) return true;
-    if (jj_scan_token(SEMI_T)) return true;
-    return false;
-  }
-
  inline bool jj_3R_664()
  {
     if (jj_done) return true;
@@ -5451,29 +5431,23 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_679()
- {
-    if (jj_done) return true;
-    if (jj_3R_691()) return true;
-    return false;
-  }
-
- inline bool jj_3R_678()
+ inline bool jj_3R_87()
  {
     if (jj_done) return true;
-    if (jj_3R_690()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3_14()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(79)) jj_scanpos = xsp;
+    if (jj_3R_187()) return true;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
- inline bool jj_3R_655()
+ inline bool jj_3R_679()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_678()) {
-    jj_scanpos = xsp;
-    if (jj_3R_679()) return true;
-    }
+    if (jj_3R_691()) return true;
     return false;
   }
 
@@ -5485,17 +5459,22 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_175()
+ inline bool jj_3R_678()
  {
     if (jj_done) return true;
-    if (jj_3R_329()) return true;
+    if (jj_3R_690()) return true;
     return false;
   }
 
- inline bool jj_3R_174()
+ inline bool jj_3R_655()
  {
     if (jj_done) return true;
-    if (jj_3R_70()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_678()) {
+    jj_scanpos = xsp;
+    if (jj_3R_679()) return true;
+    }
     return false;
   }
 
@@ -5525,6 +5504,20 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_175()
+ {
+    if (jj_done) return true;
+    if (jj_3R_329()) return true;
+    return false;
+  }
+
+ inline bool jj_3R_174()
+ {
+    if (jj_done) return true;
+    if (jj_3R_70()) return true;
+    return false;
+  }
+
  inline bool jj_3R_469()
  {
     if (jj_done) return true;
@@ -5627,6 +5620,23 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_525()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(IS_T)) return true;
+    if (jj_3R_571()) return true;
+    if (jj_scan_token(BEGIN_T)) return true;
+    if (jj_3R_572()) return true;
+    if (jj_scan_token(END_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_573()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_574()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMI_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_179()
  {
     if (jj_done) return true;
@@ -5642,20 +5652,12 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_525()
+ inline bool jj_3R_614()
  {
     if (jj_done) return true;
-    if (jj_scan_token(IS_T)) return true;
-    if (jj_3R_571()) return true;
-    if (jj_scan_token(BEGIN_T)) return true;
-    if (jj_3R_572()) return true;
-    if (jj_scan_token(END_T)) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_573()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_574()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
     return false;
   }
 
@@ -5687,6 +5689,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_356()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(STRINGLITERAL)) return true;
+    return false;
+  }
+
  inline bool jj_3R_80()
  {
     if (jj_done) return true;
@@ -5703,13 +5712,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_356()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(STRINGLITERAL)) return true;
-    return false;
-  }
-
  inline bool jj_3_12()
  {
     if (jj_done) return true;
@@ -5765,13 +5767,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_336()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    return false;
-  }
-
  inline bool jj_3R_68()
  {
     if (jj_done) return true;
@@ -5786,6 +5781,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_336()
+ {
+    if (jj_done) return true;
+    if (jj_3R_69()) return true;
+    return false;
+  }
+
  inline bool jj_3R_335()
  {
     if (jj_done) return true;
@@ -5809,6 +5811,18 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_357()
+ {
+    if (jj_done) return true;
+    if (jj_3R_59()) return true;
+    Token * xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_435()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
  inline bool jj_3R_628()
  {
     if (jj_done) return true;
@@ -5841,18 +5855,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_357()
- {
-    if (jj_done) return true;
-    if (jj_3R_59()) return true;
-    Token * xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_435()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
  inline bool jj_3R_234()
  {
     if (jj_done) return true;
@@ -5866,26 +5868,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_352()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(CHARACTER_LITERAL)) return true;
-    return false;
-  }
-
- inline bool jj_3R_614()
+ inline bool jj_3R_605()
  {
     if (jj_done) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_58()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
+    if (jj_scan_token(ALL_T)) return true;
     return false;
   }
 
- inline bool jj_3R_605()
+ inline bool jj_3R_352()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ALL_T)) return true;
+    if (jj_scan_token(CHARACTER_LITERAL)) return true;
     return false;
   }
 
@@ -5997,18 +5990,18 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_256()
+ inline bool jj_3_91()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_127()) return true;
     return false;
   }
 
- inline bool jj_3_91()
+ inline bool jj_3R_256()
  {
     if (jj_done) return true;
-    if (jj_3R_127()) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
@@ -6034,6 +6027,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3_90()
+ {
+    if (jj_done) return true;
+    if (jj_3R_126()) return true;
+    return false;
+  }
+
  inline bool jj_3R_651()
  {
     if (jj_done) return true;
@@ -6041,10 +6041,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_90()
+ inline bool jj_3R_526()
  {
     if (jj_done) return true;
-    if (jj_3R_126()) return true;
+    if (jj_3R_405()) return true;
     return false;
   }
 
@@ -6059,13 +6059,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_526()
- {
-    if (jj_done) return true;
-    if (jj_3R_405()) return true;
-    return false;
-  }
-
  inline bool jj_3_89()
  {
     if (jj_done) return true;
@@ -6104,14 +6097,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_661()
- {
-    if (jj_done) return true;
-    if (jj_3R_329()) return true;
-    if (jj_scan_token(SEMI_T)) return true;
-    return false;
-  }
-
  inline bool jj_3R_361()
  {
     if (jj_done) return true;
@@ -6134,6 +6119,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_661()
+ {
+    if (jj_done) return true;
+    if (jj_3R_329()) return true;
+    if (jj_scan_token(SEMI_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_507()
  {
     if (jj_done) return true;
@@ -6143,6 +6136,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_402()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(MINUS_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_560()
  {
     if (jj_done) return true;
@@ -6166,20 +6166,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_402()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(MINUS_T)) return true;
-    return false;
-  }
-
- inline bool jj_3_9()
- {
-    if (jj_done) return true;
-    if (jj_3R_66()) return true;
-    return false;
-  }
-
  inline bool jj_3R_314()
  {
     if (jj_done) return true;
@@ -6199,20 +6185,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_552()
+ inline bool jj_3_9()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ROR_T)) return true;
+    if (jj_3R_66()) return true;
     return false;
   }
 
- inline bool jj_3R_419()
+ inline bool jj_3R_552()
  {
     if (jj_done) return true;
-    if (jj_3R_59()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_507()) jj_scanpos = xsp;
+    if (jj_scan_token(ROR_T)) return true;
     return false;
   }
 
@@ -6230,6 +6213,16 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_419()
+ {
+    if (jj_done) return true;
+    if (jj_3R_59()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_507()) jj_scanpos = xsp;
+    return false;
+  }
+
  inline bool jj_3R_549()
  {
     if (jj_done) return true;
@@ -6254,16 +6247,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_648()
- {
-    if (jj_done) return true;
-    if (jj_3R_66()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_660()) jj_scanpos = xsp;
-    return false;
-  }
-
  inline bool jj_3R_547()
  {
     if (jj_done) return true;
@@ -6295,6 +6278,16 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_648()
+ {
+    if (jj_done) return true;
+    if (jj_3R_66()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_660()) jj_scanpos = xsp;
+    return false;
+  }
+
  inline bool jj_3R_615()
  {
     if (jj_done) return true;
@@ -6341,17 +6334,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_300()
+ inline bool jj_3_88()
  {
     if (jj_done) return true;
-    if (jj_3R_383()) return true;
+    if (jj_3R_125()) return true;
     return false;
   }
 
- inline bool jj_3_88()
+ inline bool jj_3R_300()
  {
     if (jj_done) return true;
-    if (jj_3R_125()) return true;
+    if (jj_3R_383()) return true;
     return false;
   }
 
@@ -6383,39 +6376,39 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_298()
+ inline bool jj_3_86()
  {
     if (jj_done) return true;
-    if (jj_3R_381()) return true;
+    if (jj_3R_123()) return true;
     return false;
   }
 
- inline bool jj_3R_297()
+ inline bool jj_3R_298()
  {
     if (jj_done) return true;
-    if (jj_3R_380()) return true;
+    if (jj_3R_381()) return true;
     return false;
   }
 
- inline bool jj_3_86()
+ inline bool jj_3R_118()
  {
     if (jj_done) return true;
-    if (jj_3R_123()) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
- inline bool jj_3R_296()
+ inline bool jj_3R_297()
  {
     if (jj_done) return true;
-    if (jj_3R_379()) return true;
+    if (jj_3R_380()) return true;
     return false;
   }
 
- inline bool jj_3R_118()
+ inline bool jj_3R_296()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_379()) return true;
     return false;
   }
 
@@ -6437,6 +6430,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3_84()
+ {
+    if (jj_done) return true;
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
  inline bool jj_3R_294()
  {
     if (jj_done) return true;
@@ -6451,17 +6451,17 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_84()
+ inline bool jj_3R_293()
  {
     if (jj_done) return true;
-    if (jj_3R_121()) return true;
+    if (jj_3R_377()) return true;
     return false;
   }
 
- inline bool jj_3R_293()
+ inline bool jj_3_83()
  {
     if (jj_done) return true;
-    if (jj_3R_377()) return true;
+    if (jj_3R_120()) return true;
     return false;
   }
 
@@ -6479,24 +6479,24 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_83()
+ inline bool jj_3R_290()
  {
     if (jj_done) return true;
-    if (jj_3R_120()) return true;
+    if (jj_3R_374()) return true;
     return false;
   }
 
- inline bool jj_3R_290()
+ inline bool jj_3R_289()
  {
     if (jj_done) return true;
-    if (jj_3R_374()) return true;
+    if (jj_3R_373()) return true;
     return false;
   }
 
- inline bool jj_3R_289()
+ inline bool jj_3_82()
  {
     if (jj_done) return true;
-    if (jj_3R_373()) return true;
+    if (jj_3R_119()) return true;
     return false;
   }
 
@@ -6521,10 +6521,11 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_82()
+ inline bool jj_3R_113()
  {
     if (jj_done) return true;
-    if (jj_3R_119()) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
@@ -6535,6 +6536,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_244()
+ {
+    if (jj_done) return true;
+    if (jj_3R_362()) return true;
+    return false;
+  }
+
  inline bool jj_3R_140()
  {
     if (jj_done) return true;
@@ -6596,21 +6604,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_113()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    return false;
-  }
-
- inline bool jj_3R_244()
- {
-    if (jj_done) return true;
-    if (jj_3R_362()) return true;
-    return false;
-  }
-
  inline bool jj_3_77()
  {
     if (jj_done) return true;
@@ -6629,6 +6622,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3_79()
+ {
+    if (jj_done) return true;
+    if (jj_3R_116()) return true;
+    return false;
+  }
+
  inline bool jj_3R_333()
  {
     if (jj_done) return true;
@@ -6649,13 +6649,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_79()
- {
-    if (jj_done) return true;
-    if (jj_3R_116()) return true;
-    return false;
-  }
-
  inline bool jj_3_78()
  {
     if (jj_done) return true;
@@ -6733,6 +6726,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3_76()
+ {
+    if (jj_done) return true;
+    if (jj_3R_112()) return true;
+    return false;
+  }
+
  inline bool jj_3R_94()
  {
     if (jj_done) return true;
@@ -6749,13 +6749,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3_76()
- {
-    if (jj_done) return true;
-    if (jj_3R_112()) return true;
-    return false;
-  }
-
  inline bool jj_3R_259()
  {
     if (jj_done) return true;
@@ -6781,14 +6774,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_416()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(USE_T)) return true;
-    if (jj_3R_506()) return true;
-    return false;
-  }
-
  inline bool jj_3R_422()
  {
     if (jj_done) return true;
@@ -6801,6 +6786,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_416()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(USE_T)) return true;
+    if (jj_3R_506()) return true;
+    return false;
+  }
+
  inline bool jj_3R_332()
  {
     if (jj_done) return true;
@@ -6911,14 +6904,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_316()
- {
-    if (jj_done) return true;
-    if (jj_scan_token(COMMA_T)) return true;
-    if (jj_3R_315()) return true;
-    return false;
-  }
-
  inline bool jj_3R_677()
  {
     if (jj_done) return true;
@@ -6929,15 +6914,11 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_110()
+ inline bool jj_3R_316()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(APOSTROPHE_T)) return true;
-    if (jj_3R_59()) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_240()) jj_scanpos = xsp;
+    if (jj_scan_token(COMMA_T)) return true;
+    if (jj_3R_315()) return true;
     return false;
   }
 
@@ -6960,6 +6941,18 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_110()
+ {
+    if (jj_done) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(APOSTROPHE_T)) return true;
+    if (jj_3R_59()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_240()) jj_scanpos = xsp;
+    return false;
+  }
+
  inline bool jj_3R_355()
  {
     if (jj_done) return true;
@@ -6967,6 +6960,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_266()
+ {
+    if (jj_done) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_220()
  {
     if (jj_done) return true;
@@ -6986,14 +6987,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_266()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    return false;
-  }
-
  inline bool jj_3R_125()
  {
     if (jj_done) return true;
@@ -7058,18 +7051,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_165()
- {
-    if (jj_done) return true;
-    if (jj_3R_315()) return true;
-    Token * xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_316()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
  inline bool jj_3R_116()
  {
     if (jj_done) return true;
@@ -7091,11 +7072,15 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_403()
+ inline bool jj_3R_165()
  {
     if (jj_done) return true;
-    if (jj_3R_63()) return true;
-    if (jj_scan_token(ARROW_T)) return true;
+    if (jj_3R_315()) return true;
+    Token * xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_316()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
@@ -7106,20 +7091,18 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_315()
+ inline bool jj_3R_482()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_403()) jj_scanpos = xsp;
-    if (jj_3R_404()) return true;
+    if (jj_scan_token(LESSTHAN_T)) return true;
     return false;
   }
 
- inline bool jj_3R_482()
+ inline bool jj_3R_403()
  {
     if (jj_done) return true;
-    if (jj_scan_token(LESSTHAN_T)) return true;
+    if (jj_3R_63()) return true;
+    if (jj_scan_token(ARROW_T)) return true;
     return false;
   }
 
@@ -7130,25 +7113,27 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_480()
+ inline bool jj_3R_315()
  {
     if (jj_done) return true;
-    if (jj_scan_token(EQU_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_403()) jj_scanpos = xsp;
+    if (jj_3R_404()) return true;
     return false;
   }
 
- inline bool jj_3R_479()
+ inline bool jj_3R_480()
  {
     if (jj_done) return true;
-    if (jj_scan_token(GT_T)) return true;
+    if (jj_scan_token(EQU_T)) return true;
     return false;
   }
 
- inline bool jj_3R_248()
+ inline bool jj_3R_479()
  {
     if (jj_done) return true;
-    if (jj_3R_139()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_scan_token(GT_T)) return true;
     return false;
   }
 
@@ -7183,6 +7168,14 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_248()
+ {
+    if (jj_done) return true;
+    if (jj_3R_139()) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    return false;
+  }
+
  inline bool jj_3R_115()
  {
     if (jj_done) return true;
@@ -7349,13 +7342,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_466()
- {
-    if (jj_done) return true;
-    if (jj_3R_234()) return true;
-    return false;
-  }
-
  inline bool jj_3R_61()
  {
     if (jj_done) return true;
@@ -7388,6 +7374,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_466()
+ {
+    if (jj_done) return true;
+    if (jj_3R_234()) return true;
+    return false;
+  }
+
  inline bool jj_3R_192()
  {
     if (jj_done) return true;
@@ -7452,28 +7445,6 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_535()
- {
-    if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    return false;
-  }
-
- inline bool jj_3R_464()
- {
-    if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_535()) {
-    jj_scanpos = xsp;
-    if (jj_3R_536()) {
-    jj_scanpos = xsp;
-    if (jj_3R_537()) return true;
-    }
-    }
-    return false;
-  }
-
  inline bool jj_3R_189()
  {
     if (jj_done) return true;
@@ -7488,27 +7459,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_465()
+ inline bool jj_3R_535()
  {
     if (jj_done) return true;
-    if (jj_scan_token(COLON_T)) return true;
-    if (jj_3R_84()) return true;
+    if (jj_3R_69()) return true;
     return false;
   }
 
- inline bool jj_3R_377()
+ inline bool jj_3R_464()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ALIAS_T)) return true;
-    if (jj_3R_464()) return true;
     Token * xsp;
     xsp = jj_scanpos;
-    if (jj_3R_465()) jj_scanpos = xsp;
-    if (jj_scan_token(IS_T)) return true;
-    if (jj_3R_59()) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_466()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_535()) {
+    jj_scanpos = xsp;
+    if (jj_3R_536()) {
+    jj_scanpos = xsp;
+    if (jj_3R_537()) return true;
+    }
+    }
     return false;
   }
 
@@ -7520,17 +7489,11 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_108()
+ inline bool jj_3R_465()
  {
     if (jj_done) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
-    if (jj_3R_236()) return true;
-    Token * xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_237()) { jj_scanpos = xsp; break; }
-    }
-    if (jj_scan_token(RPAREN_T)) return true;
+    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_84()) return true;
     return false;
   }
 
@@ -7560,24 +7523,26 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_341()
- {
-    if (jj_done) return true;
-    if (jj_3R_423()) return true;
-    return false;
-  }
-
- inline bool jj_3R_273()
+ inline bool jj_3R_377()
  {
     if (jj_done) return true;
-    if (jj_scan_token(MINUS_T)) return true;
+    if (jj_scan_token(ALIAS_T)) return true;
+    if (jj_3R_464()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_465()) jj_scanpos = xsp;
+    if (jj_scan_token(IS_T)) return true;
+    if (jj_3R_59()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_466()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
- inline bool jj_3R_274()
+ inline bool jj_3R_341()
  {
     if (jj_done) return true;
-    if (jj_scan_token(AMPERSAND_T)) return true;
+    if (jj_3R_423()) return true;
     return false;
   }
 
@@ -7592,39 +7557,38 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_128()
+ inline bool jj_3R_108()
  {
     if (jj_done) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_236()) return true;
     Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_272()) {
-    jj_scanpos = xsp;
-    if (jj_3R_273()) {
-    jj_scanpos = xsp;
-    if (jj_3R_274()) return true;
-    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_237()) { jj_scanpos = xsp; break; }
     }
+    if (jj_scan_token(RPAREN_T)) return true;
     return false;
   }
 
- inline bool jj_3R_272()
+ inline bool jj_3R_519()
  {
     if (jj_done) return true;
-    if (jj_scan_token(PLUS_T)) return true;
+    if (jj_3R_383()) return true;
     return false;
   }
 
- inline bool jj_3R_519()
+ inline bool jj_3R_273()
  {
     if (jj_done) return true;
-    if (jj_3R_383()) return true;
+    if (jj_scan_token(MINUS_T)) return true;
     return false;
   }
 
- inline bool jj_3_3()
+ inline bool jj_3R_274()
  {
     if (jj_done) return true;
-    if (jj_3R_60()) return true;
+    if (jj_scan_token(AMPERSAND_T)) return true;
     return false;
   }
 
@@ -7649,20 +7613,32 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_492()
+ inline bool jj_3R_128()
  {
     if (jj_done) return true;
-    if (jj_scan_token(BOX_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_272()) {
+    jj_scanpos = xsp;
+    if (jj_3R_273()) {
+    jj_scanpos = xsp;
+    if (jj_3R_274()) return true;
+    }
+    }
     return false;
   }
 
- inline bool jj_3R_493()
+ inline bool jj_3R_272()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(PLUS_T)) return true;
+    return false;
+  }
+
+ inline bool jj_3_3()
  {
     if (jj_done) return true;
-    if (jj_3R_59()) return true;
-    if (jj_scan_token(LPAREN_T)) return true;
     if (jj_3R_60()) return true;
-    if (jj_scan_token(RPAREN_T)) return true;
     return false;
   }
 
@@ -7687,46 +7663,34 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_404()
- {
-    if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_491()) {
-    jj_scanpos = xsp;
-    if (jj_3R_492()) {
-    jj_scanpos = xsp;
-    if (jj_3R_493()) return true;
-    }
-    }
-    return false;
-  }
-
- inline bool jj_3R_491()
+ inline bool jj_3R_514()
  {
     if (jj_done) return true;
-    if (jj_3R_60()) return true;
+    if (jj_3R_375()) return true;
     return false;
   }
 
- inline bool jj_3R_514()
+ inline bool jj_3R_513()
  {
     if (jj_done) return true;
-    if (jj_3R_375()) return true;
+    if (jj_3R_373()) return true;
     return false;
   }
 
- inline bool jj_3R_513()
+ inline bool jj_3R_492()
  {
     if (jj_done) return true;
-    if (jj_3R_373()) return true;
+    if (jj_scan_token(BOX_T)) return true;
     return false;
   }
 
- inline bool jj_3_2()
+ inline bool jj_3R_493()
  {
     if (jj_done) return true;
     if (jj_3R_59()) return true;
+    if (jj_scan_token(LPAREN_T)) return true;
+    if (jj_3R_60()) return true;
+    if (jj_scan_token(RPAREN_T)) return true;
     return false;
   }
 
@@ -7744,17 +7708,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_226()
+ inline bool jj_3R_404()
  {
     if (jj_done) return true;
-    if (jj_3R_165()) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_491()) {
+    jj_scanpos = xsp;
+    if (jj_3R_492()) {
+    jj_scanpos = xsp;
+    if (jj_3R_493()) return true;
+    }
+    }
     return false;
   }
 
- inline bool jj_3_1()
+ inline bool jj_3R_491()
  {
     if (jj_done) return true;
-    if (jj_3R_58()) return true;
+    if (jj_3R_60()) return true;
     return false;
   }
 
@@ -7816,58 +7788,50 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_153()
+ inline bool jj_3_2()
  {
     if (jj_done) return true;
     if (jj_3R_59()) return true;
     return false;
   }
 
- inline bool jj_3_69()
+ inline bool jj_3R_226()
  {
     if (jj_done) return true;
-    if (jj_3R_69()) return true;
-    if (jj_scan_token(COLON_T)) return true;
+    if (jj_3R_165()) return true;
     return false;
   }
 
- inline bool jj_3R_119()
+ inline bool jj_3_1()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3_69()) jj_scanpos = xsp;
-    if (jj_3R_176()) return true;
-    if (jj_scan_token(SEMI_T)) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
- inline bool jj_3R_152()
+ inline bool jj_3_69()
  {
     if (jj_done) return true;
-    if (jj_3R_58()) return true;
+    if (jj_3R_69()) return true;
+    if (jj_scan_token(COLON_T)) return true;
     return false;
   }
 
- inline bool jj_3R_151()
+ inline bool jj_3R_119()
  {
     if (jj_done) return true;
-    if (jj_scan_token(OPEN_T)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3_69()) jj_scanpos = xsp;
+    if (jj_3R_176()) return true;
+    if (jj_scan_token(SEMI_T)) return true;
     return false;
   }
 
- inline bool jj_3R_60()
+ inline bool jj_3R_153()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_151()) {
-    jj_scanpos = xsp;
-    if (jj_3R_152()) {
-    jj_scanpos = xsp;
-    if (jj_3R_153()) return true;
-    }
-    }
+    if (jj_3R_59()) return true;
     return false;
   }
 
@@ -7888,11 +7852,10 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_656()
+ inline bool jj_3R_152()
  {
     if (jj_done) return true;
-    if (jj_scan_token(ACCESS_T)) return true;
-    if (jj_3R_84()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
@@ -7903,17 +7866,25 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_225()
+ inline bool jj_3R_151()
  {
     if (jj_done) return true;
-    if (jj_scan_token(BASED_LITERAL)) return true;
+    if (jj_scan_token(OPEN_T)) return true;
     return false;
   }
 
- inline bool jj_3R_224()
+ inline bool jj_3R_60()
  {
     if (jj_done) return true;
-    if (jj_scan_token(INTEGER)) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_151()) {
+    jj_scanpos = xsp;
+    if (jj_3R_152()) {
+    jj_scanpos = xsp;
+    if (jj_3R_153()) return true;
+    }
+    }
     return false;
   }
 
@@ -7924,39 +7895,32 @@ void parseInline();
     return false;
   }
 
- inline bool jj_3R_223()
+ inline bool jj_3R_656()
  {
     if (jj_done) return true;
-    if (jj_scan_token(DECIMAL_LITERAL)) return true;
+    if (jj_scan_token(ACCESS_T)) return true;
+    if (jj_3R_84()) return true;
     return false;
   }
 
- inline bool jj_3R_103()
+ inline bool jj_3R_203()
  {
     if (jj_done) return true;
-    Token * xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_223()) {
-    jj_scanpos = xsp;
-    if (jj_3R_224()) {
-    jj_scanpos = xsp;
-    if (jj_3R_225()) return true;
-    }
-    }
+    if (jj_3R_86()) return true;
     return false;
   }
 
- inline bool jj_3R_203()
+ inline bool jj_3R_202()
  {
     if (jj_done) return true;
-    if (jj_3R_86()) return true;
+    if (jj_3R_350()) return true;
     return false;
   }
 
- inline bool jj_3R_202()
+ inline bool jj_3R_225()
  {
     if (jj_done) return true;
-    if (jj_3R_350()) return true;
+    if (jj_scan_token(BASED_LITERAL)) return true;
     return false;
   }
 
@@ -7988,6 +7952,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_224()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(INTEGER)) return true;
+    return false;
+  }
+
  inline bool jj_3_66()
  {
     if (jj_done) return true;
@@ -7995,6 +7966,28 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3R_223()
+ {
+    if (jj_done) return true;
+    if (jj_scan_token(DECIMAL_LITERAL)) return true;
+    return false;
+  }
+
+ inline bool jj_3R_103()
+ {
+    if (jj_done) return true;
+    Token * xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_223()) {
+    jj_scanpos = xsp;
+    if (jj_3R_224()) {
+    jj_scanpos = xsp;
+    if (jj_3R_225()) return true;
+    }
+    }
+    return false;
+  }
+
  inline bool jj_3_65()
  {
     if (jj_done) return true;
@@ -8894,6 +8887,13 @@ void parseInline();
     return false;
   }
 
+ inline bool jj_3_43()
+ {
+    if (jj_done) return true;
+    if (jj_3R_93()) return true;
+    return false;
+  }
+
 
 public: 
   TokenManager *token_source;
@@ -8966,49 +8966,31 @@ public:
   void jj_rescan_token();
 
   void jj_save(int index, int xla);
-typedef unsigned long long uint64;
-
-static Entry* current_root;
-static Entry* tempEntry;
-static Entry*  lastEntity  ;
-static Entry*  lastCompound  ;
-static std::shared_ptr<Entry> current;
-static QCString compSpec;
-static QCString currName;
-static int levelCounter;
-static QCString confName;
-static QCString genLabels;
-static QCString lab;
-static QCString forL;
-static int param_sec ;
-static int parse_sec;
-static int currP;
-
-//----------------------------------------
-
-static void setLineParsed(int tok);
-static int getLine(int tok);
-static int getLine();
-static void lineCount(const char*);
-static void lineCount();
-static void addProto(const char *s1,const char *s2,const char *s3,const char *s4,const char *s5,const char *s6);
-static void addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf);
-static void createFunction(const char *impure,uint64 spec,const char *fname);
-static void addVhdlType(const char *n,int startLine,int section, uint64 spec,const char* args,const char* type,Protection prot);
-static void addCompInst(const char *n, const char* instName, const char* comp,int iLine);
-static void handleCommentBlock(const char* doc,bool brief);
-static void handleFlowComment(const char*);
-static void initEntry(Entry *e);
-static  void newEntry();
-static  bool isFuncProcProced();
-static void pushLabel(QCString &,QCString&);
-static  QCString popLabel(QCString & q);
-static  bool addLibUseClause(const QCString &type);
-static  void mapLibPackage( Entry* root);
-static void createFlow();
-static void error_skipto(int kind);
-static void oneLineComment(QCString qcs);
-static void setMultCommentLine();
+struct SharedState
+{
+  std::shared_ptr<Entry> current_root;
+  std::shared_ptr<Entry> tempEntry;
+  std::shared_ptr<Entry> lastEntity;
+  std::shared_ptr<Entry> lastCompound;
+  std::shared_ptr<Entry> current;
+  QCString compSpec;
+  QCString currName;
+  int levelCounter = 0;
+  QCString confName;
+  QCString genLabels;
+  QCString lab;
+  int param_sec = 0;
+  int parse_sec = 0;
+  int currP = 0;
+};
+
+VHDLOutlineParser *m_outlineParser;
+SharedState *m_sharedState;
+
+void setOutlineParser(VHDLOutlineParser* p) { m_outlineParser=p; }
+VHDLOutlineParser *outlineParser() const { return m_outlineParser; }
+void setSharedState(SharedState *s) { m_sharedState=s; }
+void clearError() { hasError = false; }
 
 private:
   bool jj_done;
diff --git a/vhdlparser/VhdlParserErrorHandler.hpp b/vhdlparser/VhdlParserErrorHandler.hpp
index 9576ce6..0337f1f 100644
--- a/vhdlparser/VhdlParserErrorHandler.hpp
+++ b/vhdlparser/VhdlParserErrorHandler.hpp
@@ -14,42 +14,55 @@ const char *getVhdlFileName(void);
 namespace vhdl { namespace parser {
 
 class VhdlErrorHandler: public ErrorHandler
-  {
+{
+  public:
+    VhdlErrorHandler(const char *fileName) : m_fileName(fileName) {}
+
     virtual void handleUnexpectedToken(int expectedKind, JAVACC_STRING_TYPE expectedToken, Token *actual, VhdlParser *parser)
     {
-      warn(getVhdlFileName(),actual->beginLine,"syntax error '%s'",actual->image.data());
+      warn(m_fileName,actual->beginLine,"syntax error '%s'",actual->image.data());
       error_count++;
       throw std::exception();
     }
 
     virtual void handleParseError(Token *last, Token *unexpected, JAVACC_SIMPLE_STRING production, VhdlParser *parser)
     {
-      warn(getVhdlFileName(),last->beginLine,"unexpected token: '%s'", unexpected->image.data());
+      warn(m_fileName,last->beginLine,"unexpected token: '%s'", unexpected->image.data());
       error_count++;
       throw std::exception();
     }
 
     virtual void handleOtherError(JAVACC_STRING_TYPE message, VhdlParser *parser)
     {
-      warn(getVhdlFileName(), -1, "unexpected error: '%s'", (char*)message.c_str());
+      warn(m_fileName, -1, "unexpected error: '%s'", (char*)message.c_str());
       error_count++;
       throw std::exception();
     }
-  };
 
-class VhdlTokenManagerErrorHandler: public TokenManagerErrorHandler {
+  private:
+    QCString m_fileName;
+};
+
+class VhdlTokenManagerErrorHandler: public TokenManagerErrorHandler
+{
+  public:
+    VhdlTokenManagerErrorHandler(const char *fileName) : m_fileName(fileName) {}
+
     virtual void lexicalError(bool EOFSeen, int lexState, int errorLine, int errorColumn, JAVACC_STRING_TYPE errorAfter, JAVACC_CHAR_TYPE curChar, VhdlParserTokenManager* token_manager)
     {
-      warn(getVhdlFileName(),errorLine,"Lexical error, Encountered: '%c' after: '%s'",curChar, (EOFSeen? "EOF" : (const char*)errorAfter.c_str()));
+      warn(m_fileName,errorLine,"Lexical error, Encountered: '%c' after: '%s'",curChar, (EOFSeen? "EOF" : (const char*)errorAfter.c_str()));
     }
 
     virtual void lexicalError(JAVACC_STRING_TYPE errorMessage, VhdlParserTokenManager* token_manager)
     {
-      warn(getVhdlFileName(),-1,"Unknown error: '%s'", (char*)errorMessage.c_str());
+      warn(m_fileName,-1,"Unknown error: '%s'", (char*)errorMessage.c_str());
     }
-  };
-}
-}
+
+  private:
+    QCString m_fileName;
+};
+
+} }
 
 #endif
 
diff --git a/vhdlparser/VhdlParserIF.cpp b/vhdlparser/VhdlParserIF.cpp
deleted file mode 100644
index 676546b..0000000
--- a/vhdlparser/VhdlParserIF.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-
-#include "VhdlParserTokenManager.h"
-#include "VhdlParserErrorHandler.hpp"
-#include "VhdlParser.h"
-#include "VhdlParserIF.h"
-#include "CharStream.h"
-
-using namespace vhdl::parser;
-
-static VhdlParser * myParser=0;
-
-void  VhdlParserIF::parseVhdlfile(const char* inputBuffer,bool inLine) 
-{
-  JAVACC_STRING_TYPE s =inputBuffer;
-  CharStream *stream = new CharStream(s.c_str(), (int)s.size(), 1, 1);
-  VhdlParserTokenManager *tokenManager = new VhdlParserTokenManager(stream);
-  VhdlTokenManagerErrorHandler *myTokErr=new VhdlTokenManagerErrorHandler();
-  tokenManager->setErrorHandler(myTokErr);
-  myParser=new VhdlParser(tokenManager);
-  VhdlErrorHandler *myErr=new VhdlErrorHandler();
-  myParser->setErrorHandler(myErr);
-  try
-  {
-    if(inLine)
-    {
-      myParser->parseInline();
-    }
-    else
-    {
-      myParser->design_file();
-    }
-  }
-  catch( std::exception &){ /* fprintf(stderr,"\n[%s]",e.what()); */ }
-  //  fprintf(stderr,"\n\nparsed lines: %d\n",yyLineNr);
-  //  fprintf(stderr,"\n\nerrors : %d\n\n",myErr->getErrorCount());
-  delete myParser;
-}
-
-void VhdlParser::error_skipto(int kind)
-{
-  Token *op;
-  do
-  {
-     Token *t = myParser->getNextToken();// step to next token
-	 op=myParser->getToken(1);           // get first token
-     if (op==0) break;
-    //fprintf(stderr,"\n %s",t->image.data());
-  } while (op->kind != kind);
-  myParser->hasError=false;
-  // 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".
-
-}
diff --git a/vhdlparser/VhdlParserIF.h b/vhdlparser/VhdlParserIF.h
deleted file mode 100644
index d11389b..0000000
--- a/vhdlparser/VhdlParserIF.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef VHDLPARSERIF
-#define VHDLPARSERIF
-
-#include "VhdlParser.h"
-
-class VhdlParserIF
-{
-  public:
-  static void  parseVhdlfile(const char* inputBuffer,bool inLine);
-
-};
-#endif
diff --git a/vhdlparser/VhdlParserTokenManager.cc b/vhdlparser/VhdlParserTokenManager.cc
index 5edbfc5..2970785 100644
--- a/vhdlparser/VhdlParserTokenManager.cc
+++ b/vhdlparser/VhdlParserTokenManager.cc
@@ -3453,7 +3453,7 @@ void  VhdlParserTokenManager::SkipLexicalActions(Token *matchedToken){
    {
       case 3 : {
          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-        ::vhdl::parser::VhdlParser::lineCount();
+        parser->outlineParser()->lineCount();
          break;
        }
       case 6 : {
@@ -3461,36 +3461,36 @@ void  VhdlParserTokenManager::SkipLexicalActions(Token *matchedToken){
     {
     QCString doc(image.data());
     int count=doc.contains("--!");
-    ::vhdl::parser::VhdlParser::setMultCommentLine();
-    ::vhdl::parser::VhdlParser::lineCount(image.data());
+    parser->outlineParser()->setMultCommentLine();
+    parser->outlineParser()->lineCount(image.data());
     if (count == 1)
-      ::vhdl::parser::VhdlParser::oneLineComment(doc);
+      parser->outlineParser()->oneLineComment(doc);
     else
-      ::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),FALSE); ;
+      parser->outlineParser()->handleCommentBlock(image.data(),FALSE); ;
     }
          break;
        }
       case 7 : {
          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                                                                               ::vhdl::parser::VhdlParser::handleFlowComment(image.data());
+                                                                               parser->outlineParser()->handleFlowComment(image.data());
          break;
        }
       case 8 : {
          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-    ::vhdl::parser::VhdlParser::lineCount(image.data());
+    parser->outlineParser()->lineCount(image.data());
          break;
        }
       case 9 : {
          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
    {
      QCString q = filter2008VhdlComment(image.data());
-     ::vhdl::parser::VhdlParser::handleCommentBlock(q.data(),TRUE);image.clear();
+     parser->outlineParser()->handleCommentBlock(q.data(),TRUE);image.clear();
    }
          break;
        }
       case 10 : {
          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-      ::vhdl::parser::VhdlParser::lineCount(image.data());image.clear();
+      parser->outlineParser()->lineCount(image.data());image.clear();
          break;
        }
       default :
@@ -3503,123 +3503,123 @@ void  VhdlParserTokenManager::TokenLexicalActions(Token *matchedToken){
    {
       case 17 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                                    ::vhdl::parser::VhdlParser::setLineParsed(ARCHITECTURE_T);
+                                    parser->outlineParser()->setLineParsed(ARCHITECTURE_T);
          break;
        }
       case 18 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                      VhdlParser::setLineParsed(ARRAY_T);
+                      parser->outlineParser()->setLineParsed(ARRAY_T);
          break;
        }
       case 22 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                              ::vhdl::parser::VhdlParser::setLineParsed(ATTRIBUTE_T);
+                              parser->outlineParser()->setLineParsed(ATTRIBUTE_T);
          break;
        }
       case 25 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                    ::vhdl::parser::VhdlParser::setLineParsed(BODY_T);
+                    parser->outlineParser()->setLineParsed(BODY_T);
          break;
        }
       case 28 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                              VhdlParser::setLineParsed(COMPONENT_T);
+                              parser->outlineParser()->setLineParsed(COMPONENT_T);
          break;
        }
       case 30 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                                      VhdlParser::setLineParsed(CONFIGURATION_T);
+                                      parser->outlineParser()->setLineParsed(CONFIGURATION_T);
          break;
        }
       case 31 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                             VhdlParser::setLineParsed(CONSTANT_T);
+                             parser->outlineParser()->setLineParsed(CONSTANT_T);
          break;
        }
       case 32 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                          VhdlParser::setLineParsed(CONTEXT_T);
+                          parser->outlineParser()->setLineParsed(CONTEXT_T);
          break;
        }
       case 39 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                  VhdlParser::setLineParsed(END_T);
+                  parser->outlineParser()->setLineParsed(END_T);
          break;
        }
       case 40 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                        VhdlParser::setLineParsed(ENTITY_T);
+                        parser->outlineParser()->setLineParsed(ENTITY_T);
          break;
        }
       case 43 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                    VhdlParser::setLineParsed(FILE_T);
+                    parser->outlineParser()->setLineParsed(FILE_T);
          break;
        }
       case 46 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                             VhdlParser::setLineParsed(FUNCTION_T);
+                             parser->outlineParser()->setLineParsed(FUNCTION_T);
          break;
        }
       case 49 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                      VhdlParser::setLineParsed(GROUP_T);
+                      parser->outlineParser()->setLineParsed(GROUP_T);
          break;
        }
       case 58 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                          VhdlParser::setLineParsed(LIBRARY_T);
+                          parser->outlineParser()->setLineParsed(LIBRARY_T);
          break;
        }
       case 76 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                          ::vhdl::parser::VhdlParser::setLineParsed(PACKAGE_T);
+                          parser->outlineParser()->setLineParsed(PACKAGE_T);
          break;
        }
       case 78 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                    ::vhdl::parser::VhdlParser::setLineParsed(PORT_T);
+                    parser->outlineParser()->setLineParsed(PORT_T);
          break;
        }
       case 80 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                              ::vhdl::parser::VhdlParser::setLineParsed(PROCEDURE_T);
+                              parser->outlineParser()->setLineParsed(PROCEDURE_T);
          break;
        }
       case 81 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                          ::vhdl::parser::VhdlParser::setLineParsed(PROCESS_T);
+                          parser->outlineParser()->setLineParsed(PROCESS_T);
          break;
        }
       case 86 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                        ::vhdl::parser::VhdlParser::setLineParsed(RECORD_T);
+                        parser->outlineParser()->setLineParsed(RECORD_T);
          break;
        }
       case 100 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                        ::vhdl::parser::VhdlParser::setLineParsed(SIGNAL_T);
+                        parser->outlineParser()->setLineParsed(SIGNAL_T);
          break;
        }
       case 107 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                          ::vhdl::parser::VhdlParser::setLineParsed(SUBTYPE_T);
+                          parser->outlineParser()->setLineParsed(SUBTYPE_T);
          break;
        }
       case 111 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                    ::vhdl::parser::VhdlParser::setLineParsed(TYPE_T);
+                    parser->outlineParser()->setLineParsed(TYPE_T);
          break;
        }
       case 113 : {
         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
-                      ::vhdl::parser::VhdlParser::setLineParsed(UNITS_T);
+                      parser->outlineParser()->setLineParsed(UNITS_T);
          break;
        }
       case 137 : {
         image.append(jjstrLiteralImages[137]);
         lengthOfMatch = jjstrLiteralImages[137].length();
-                  ::vhdl::parser::VhdlParser::setLineParsed(SEMI_T);
+                  parser->outlineParser()->setLineParsed(SEMI_T);
          break;
        }
       default :
diff --git a/vhdlparser/vhdlparser.jj b/vhdlparser/vhdlparser.jj
index 3151528..7b3f5e7 100644
--- a/vhdlparser/vhdlparser.jj
+++ b/vhdlparser/vhdlparser.jj
@@ -25,56 +25,68 @@ options {
 
 PARSER_BEGIN(VhdlParser)
 
-typedef unsigned long long uint64;
-
-static Entry* current_root;
-static Entry* tempEntry;
-static Entry*  lastEntity  ;
-static Entry*  lastCompound  ;
-static std::shared_ptr<Entry> current;
-static QCString compSpec;
-static QCString currName;
-static int levelCounter;
-static QCString confName;
-static QCString genLabels;
-static QCString lab;
-static QCString forL;
-static int param_sec ;
-static int parse_sec;
-static int currP;
+
+struct SharedState
+{
+  std::shared_ptr<Entry> current_root;
+  std::shared_ptr<Entry> tempEntry;
+  std::shared_ptr<Entry> lastEntity;
+  std::shared_ptr<Entry> lastCompound;
+  std::shared_ptr<Entry> current;
+  QCString compSpec;
+  QCString currName;
+  int levelCounter = 0;
+  QCString confName;
+  QCString genLabels;
+  QCString lab;
+  int param_sec = 0;
+  int parse_sec = 0;
+  int currP = 0;
+};
+
+VHDLOutlineParser *m_outlineParser;
+SharedState *m_sharedState;
+
+void setOutlineParser(VHDLOutlineParser* p) { m_outlineParser=p; }
+VHDLOutlineParser *outlineParser() const { return m_outlineParser; }
+void setSharedState(SharedState *s) { m_sharedState=s; }
+void clearError() { hasError = false; }
+
+//typedef unsigned long long uint64;
 
 //----------------------------------------
 
-static void setLineParsed(int tok);
-static int getLine(int tok);
-static int getLine();
-static void lineCount(const char*);
-static void lineCount();
-static void addProto(const char *s1,const char *s2,const char *s3,const char *s4,const char *s5,const char *s6);
-static void addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf);
-static void createFunction(const char *impure,uint64 spec,const char *fname);
-static void addVhdlType(const char *n,int startLine,int section, uint64 spec,const char* args,const char* type,Protection prot);
-static void addCompInst(const char *n, const char* instName, const char* comp,int iLine);
-static void handleCommentBlock(const char* doc,bool brief);
-static void handleFlowComment(const char*);
-static void initEntry(Entry *e);
-static  void newEntry();
-static  bool isFuncProcProced();
-static void pushLabel(QCString &,QCString&);
-static  QCString popLabel(QCString & q);
-static  bool addLibUseClause(const QCString &type);
-static  void mapLibPackage( Entry* root);
-static void createFlow();
-static void error_skipto(int kind);
-static void oneLineComment(QCString qcs);
-static void setMultCommentLine();
+//void setLineParsed(int tok);
+//int getLine(int tok);
+//int getLine();
+//void lineCount(const char*);
+//void lineCount();
+//void outlineParser()->addProto(const char *s1,const char *s2,const char *s3,const char *s4,const char *s5,const char *s6);
+//void addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf);
+//void createFunction(const char *impure,uint64 spec,const char *fname);
+//void outlineParser()->addVhdlType(const char *n,int startLine,int section, uint64 spec,const char* args,const char* type,Protection prot);
+//void outlineParser()->addCompInst(const char *n, const char* instName, const char* comp,int iLine);
+//void handleCommentBlock(const char* doc,bool brief);
+//void handleFlowComment(const char*);
+//void initEntry(Entry *e);
+//void outlineParser()->newEntry();
+//bool isFuncProcProced();
+//void pushLabel(QCString &,QCString&);
+//QCString popLabel(QCString & q);
+//bool addLibUseClause(const QCString &type);
+//void mapLibPackage( Entry* root);
+//void createFlow();
+//void outlineParser()->error_skipto(int kind);
+//void oneLineComment(QCString qcs);
+//void setMultCommentLine();
+
 PARSER_END(VhdlParser)
 
 SKIP :
 {
   " "
 | "\t"
-| "\n" {::vhdl::parser::VhdlParser::lineCount();}
+| "\n" {parser->outlineParser()->lineCount();}
 | "\r"
 }
 
@@ -88,19 +100,19 @@ SKIP:
     {
     QCString doc(image.data());
     int count=doc.contains("--!");
-    ::vhdl::parser::VhdlParser::setMultCommentLine();
-    ::vhdl::parser::VhdlParser::lineCount(image.data());
+    parser->outlineParser()->setMultCommentLine();
+    parser->outlineParser()->lineCount(image.data());
     if (count == 1)
-      ::vhdl::parser::VhdlParser::oneLineComment(doc);
+      parser->outlineParser()->oneLineComment(doc);
     else
-      ::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),FALSE); ;
+      parser->outlineParser()->handleCommentBlock(image.data(),FALSE); ;
     }
 
   }
-  |<VHDL_FLOWCHART_COMMENT: "--#" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>  { ::vhdl::parser::VhdlParser::handleFlowComment(image.data());}
+  |<VHDL_FLOWCHART_COMMENT: "--#" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>  { parser->outlineParser()->handleFlowComment(image.data());}
   |<VHDL_COMMENT: "--" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>
   {
-    ::vhdl::parser::VhdlParser::lineCount(image.data());}
+    parser->outlineParser()->lineCount(image.data());}
   }
 
 // VHDL 2008  comment /* .... */
@@ -111,12 +123,12 @@ SKIP :
   {
    {
      QCString q = filter2008VhdlComment(image.data());
-     ::vhdl::parser::VhdlParser::handleCommentBlock(q.data(),TRUE);image.clear();
+     parser->outlineParser()->handleCommentBlock(q.data(),TRUE);image.clear();
    }
   }
   | <MULT_VHDL_2008_COMMENT : "/*" (~["*"])* "*" ("*" | ~["*","/"] (~["*"])* "*")* "/">
     {
-      ::vhdl::parser::VhdlParser::lineCount(image.data());image.clear();}
+      parser->outlineParser()->lineCount(image.data());image.clear();}
     }
 
 /* KEYWORDS */
@@ -129,39 +141,39 @@ TOKEN [IGNORE_CASE] :
 | <ALIAS_T: "alias">
 | <ALL_T: "all">
 | <AND_T: "and">
-| <ARCHITECTURE_T: "architecture"> {::vhdl::parser::VhdlParser::setLineParsed(ARCHITECTURE_T);}
-| <ARRAY_T: "array"> {VhdlParser::setLineParsed(ARRAY_T);}
+| <ARCHITECTURE_T: "architecture"> {parser->outlineParser()->setLineParsed(ARCHITECTURE_T);}
+| <ARRAY_T: "array"> {parser->outlineParser()->setLineParsed(ARRAY_T);}
 | <ASSERT_T: "assert">
 | <ASSUME_T: "assume">
 | <ASSUME_GUARANTEE_T: "assume_guarantee">
-| <ATTRIBUTE_T: "attribute"> {::vhdl::parser::VhdlParser::setLineParsed(ATTRIBUTE_T);}
+| <ATTRIBUTE_T: "attribute"> {parser->outlineParser()->setLineParsed(ATTRIBUTE_T);}
 | <BEGIN_T: "begin">
 | <BLOCK_T: "block">
-| <BODY_T: "body"> {::vhdl::parser::VhdlParser::setLineParsed(BODY_T);}
+| <BODY_T: "body"> {parser->outlineParser()->setLineParsed(BODY_T);}
 | <BUFFER_T: "buffer">
 | <BUS_T: "bus">
-| <COMPONENT_T: "component"> {VhdlParser::setLineParsed(COMPONENT_T);}
+| <COMPONENT_T: "component"> {parser->outlineParser()->setLineParsed(COMPONENT_T);}
 | <CASE_T: "case">
-| <CONFIGURATION_T: "configuration"> {VhdlParser::setLineParsed(CONFIGURATION_T);}
-| <CONSTANT_T: "constant">  {VhdlParser::setLineParsed(CONSTANT_T);}
-| <CONTEXT_T: "context"> {VhdlParser::setLineParsed(CONTEXT_T);}
+| <CONFIGURATION_T: "configuration"> {parser->outlineParser()->setLineParsed(CONFIGURATION_T);}
+| <CONSTANT_T: "constant">  {parser->outlineParser()->setLineParsed(CONSTANT_T);}
+| <CONTEXT_T: "context"> {parser->outlineParser()->setLineParsed(CONTEXT_T);}
 | <COVER_T: "cover">
 | <DEFAULT_T: "default">
 | <DISCONNECT_T: "disconnect">
 | <DOWNTO_T: "downto">
 | <ELSE_T: "else">
 | <ELSIF_T: "elsif">
-| <END_T: "end"> {VhdlParser::setLineParsed(END_T);}
-| <ENTITY_T: "entity"> {VhdlParser::setLineParsed(ENTITY_T);}
+| <END_T: "end"> {parser->outlineParser()->setLineParsed(END_T);}
+| <ENTITY_T: "entity"> {parser->outlineParser()->setLineParsed(ENTITY_T);}
 | <EXIT_T: "exit">
 | <FAIRNESS_T: "fairness">
-| <FILE_T: "file"> {VhdlParser::setLineParsed(FILE_T);}
+| <FILE_T: "file"> {parser->outlineParser()->setLineParsed(FILE_T);}
 | <FOR_T: "for">
 | <FORCE_T: "force">
-| <FUNCTION_T: "function">  {VhdlParser::setLineParsed(FUNCTION_T);}
+| <FUNCTION_T: "function">  {parser->outlineParser()->setLineParsed(FUNCTION_T);}
 | <GENERATE_T: "generate">
 | <GENERIC_T: "generic">
-| <GROUP_T: "group"> {VhdlParser::setLineParsed(GROUP_T);}
+| <GROUP_T: "group"> {parser->outlineParser()->setLineParsed(GROUP_T);}
 | <GUARDED_T: "guarded">
 | <IF_T: "if">
 | <IMPURE_T: "impure">
@@ -170,7 +182,7 @@ TOKEN [IGNORE_CASE] :
 | <INOUT_T: "inout">
 | <IS_T: "is">
 | <LABEL_T: "label">
-| <LIBRARY_T: "library"> {VhdlParser::setLineParsed(LIBRARY_T);}
+| <LIBRARY_T: "library"> {parser->outlineParser()->setLineParsed(LIBRARY_T);}
 | <LINKAGE_T: "linkage">
 | <LITERAL_T: "literal">
 | <LOOP_T: "loop">
@@ -188,17 +200,17 @@ TOKEN [IGNORE_CASE] :
 | <OR_T: "or">
 | <OTHER_T: "others">
 | <OUT_T: "out">
-| <PACKAGE_T: "package"> {::vhdl::parser::VhdlParser::setLineParsed(PACKAGE_T);}
+| <PACKAGE_T: "package"> {parser->outlineParser()->setLineParsed(PACKAGE_T);}
 | <PARAMETER_T: "parameter">
-| <PORT_T: "port"> {::vhdl::parser::VhdlParser::setLineParsed(PORT_T);}
+| <PORT_T: "port"> {parser->outlineParser()->setLineParsed(PORT_T);}
 | <POSTPONED_T: "postponed">
-| <PROCEDURE_T: "procedure"> {::vhdl::parser::VhdlParser::setLineParsed(PROCEDURE_T);}
-| <PROCESS_T: "process"> {::vhdl::parser::VhdlParser::setLineParsed(PROCESS_T);}
+| <PROCEDURE_T: "procedure"> {parser->outlineParser()->setLineParsed(PROCEDURE_T);}
+| <PROCESS_T: "process"> {parser->outlineParser()->setLineParsed(PROCESS_T);}
 | <PROPERTY_T: "property">
 | <PROTECTED_T: "protected">
 | <PURE_T: "pure">
 | <RANGE_T: "range">
-| <RECORD_T: "record"> {::vhdl::parser::VhdlParser::setLineParsed(RECORD_T);}
+| <RECORD_T: "record"> {parser->outlineParser()->setLineParsed(RECORD_T);}
 | <REGISTER_T: "register">
 | <REJECT_T: "reject">
 | <RELEASE_T: "release">
@@ -212,20 +224,20 @@ TOKEN [IGNORE_CASE] :
 | <SELECT_T: "select">
 | <SEQUENCE_T: "sequence">
 | <SEVERITY_T: "severity">
-| <SIGNAL_T: "signal"> {::vhdl::parser::VhdlParser::setLineParsed(SIGNAL_T);}
+| <SIGNAL_T: "signal"> {parser->outlineParser()->setLineParsed(SIGNAL_T);}
 | <SHARED_T: "shared">
 | <SLA_T: "sla">
 | <SLL_T: "sll">
 | <SRA_T: "sra">
 | <SRL_T: "srl">
 | <STRONG_T: "strong">
-| <SUBTYPE_T: "subtype"> {::vhdl::parser::VhdlParser::setLineParsed(SUBTYPE_T);}
+| <SUBTYPE_T: "subtype"> {parser->outlineParser()->setLineParsed(SUBTYPE_T);}
 | <THEN_T: "then">
 | <TO_T: "to">
 | <TRANSPORT_T: "transport">
-| <TYPE_T: "type"> {::vhdl::parser::VhdlParser::setLineParsed(TYPE_T);}
+| <TYPE_T: "type"> {parser->outlineParser()->setLineParsed(TYPE_T);}
 | <UNAFFECTED_T: "unaffected">
-| <UNITS_T: "units"> {::vhdl::parser::VhdlParser::setLineParsed(UNITS_T);}
+| <UNITS_T: "units"> {parser->outlineParser()->setLineParsed(UNITS_T);}
 | <UNTIL_T: "until">
 | <USE_T: "use">
 | <VARIABLE_T: "variable">
@@ -255,7 +267,7 @@ TOKEN :
 | < COMMA_T: "," >
 | < VARASSIGN_T: ":=" >
 | < COLON_T: ":" >
-| < SEMI_T: ";" >{::vhdl::parser::VhdlParser::setLineParsed(SEMI_T);}
+| < SEMI_T: ";" >{parser->outlineParser()->setLineParsed(SEMI_T);}
 | < LESSTHAN_T: "<=" >
 | < GREATERTHAN_T: ">=" >
 | < LT_T: "<" >
@@ -380,7 +392,7 @@ QCString alias_declaration() :  {QCString s,s1,s2;}
  <IS_T> { s+=" is "; } s1=name() {s+=s1;} [s1=signature() {s+=s1;}]
  <SEMI_T>
 {
- addVhdlType(s2.data(),getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
+ outlineParser()->addVhdlType(s2.data(),outlineParser()->getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
 
  return s2+" "+s+";";
 }
@@ -395,29 +407,34 @@ QCString alias_designator()  : {Token *tok=0;QCString s;}
 
 void allocator()  :{}
 {
- LOOKAHEAD(3)
- <NEW_T> qualified_expression()
- |  <NEW_T>  subtype_indication()
+  LOOKAHEAD(3)
+     <NEW_T> qualified_expression()
+  |  <NEW_T> subtype_indication()
 }
 
 void architecture_body() : {QCString s,s1;}
 {
 
-    <ARCHITECTURE_T> s=identifier() <OF_T> s1=name() <IS_T>
-    {
-                  QCString t=s1+"::"+s;
-                  genLabels.resize(0);
-                  pushLabel(genLabels,s1);
-                  lastCompound=current.get();
-                  addVhdlType(t,getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
-    }
-   try{
-   architecture_declarative_part()
-    }catch(...){error_skipto(BEGIN_T);}
-   <BEGIN_T>
-   architecture_statement_part()
+  <ARCHITECTURE_T> s=identifier() <OF_T> s1=name() <IS_T>
+  {
+    QCString t=s1+"::"+s;
+    m_sharedState->genLabels.resize(0);
+    outlineParser()->pushLabel(m_sharedState->genLabels,s1);
+    m_sharedState->lastCompound=m_sharedState->current;
+    outlineParser()->addVhdlType(t,outlineParser()->getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
+  }
+  try
+  {
+    architecture_declarative_part()
+  }
+  catch(...)
+  {
+    outlineParser()->error_skipto(BEGIN_T);
+  }
+  <BEGIN_T>
+  architecture_statement_part()
   <END_T> [<ARCHITECTURE_T>] [name()] <SEMI_T>
-   { lastEntity=0;lastCompound=0; genLabels.resize(0); }
+  { m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0); }
 }
 
 void architecture_declarative_part() : {}
@@ -476,7 +493,7 @@ QCString attribute_declaration() : {QCString s,s1;}
 {
  <ATTRIBUTE_T> s=identifier() <COLON_T> s1=type_mark() <SEMI_T>
   {
-    addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
+    outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
     return " attribute "+s+":"+s1+";";
   }
  }
@@ -498,7 +515,7 @@ QCString attribute_specification():  {QCString s,s1,s2;}
   <ATTRIBUTE_T> s=attribute_designator() <OF_T> s1=entity_specification() <IS_T> s2=expression() <SEMI_T>
   {
    QCString t= s1+" is "+s2;
-   addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
+   outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
    return " attribute "+s+" of "+s1+ " is "+s2+";";
   }
 }
@@ -605,14 +622,14 @@ void block_specification() :  {}
 void block_statement() :  {QCString s;}
 {
   s=identifier() <COLON_T>
-        <BLOCK_T> { pushLabel(genLabels,s); }[ <LPAREN_T> expression() <RPAREN_T> ] [ <IS_T> ]
+        <BLOCK_T> { outlineParser()->pushLabel(m_sharedState->genLabels,s); }[ <LPAREN_T> expression() <RPAREN_T> ] [ <IS_T> ]
             block_header()
             block_declarative_part()
             <BEGIN_T>
             block_statement_part()
             <END_T> <BLOCK_T> [ identifier() ] <SEMI_T>
             {
-              genLabels=popLabel(genLabels);
+              m_sharedState->genLabels=outlineParser()->popLabel(m_sharedState->genLabels);
             }
 }
 
@@ -683,12 +700,12 @@ void component_configuration () :{}
 void component_declaration() :  {QCString s;}
 {
  <COMPONENT_T> s=identifier() [ <IS_T> ]
-   { currP=VhdlDocGen::COMPONENT; }
+   { m_sharedState->currP=VhdlDocGen::COMPONENT; }
   [ generic_clause() ]
   [ port_clause() ]
    {
-     addVhdlType(s.data(),getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
-     currP=0;
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
+     m_sharedState->currP=0;
   }
   <END_T> <COMPONENT_T> [ identifier() ] <SEMI_T>
 
@@ -706,7 +723,7 @@ s=identifier() <COLON_T>
          s1=VhdlDocGen::getIndexWord(s1.data(),1);
        }
 
-       addCompInst(s.lower().data(),s1.lower().data(),s3.data(),getLine());
+       outlineParser()->addCompInst(s.lower().data(),s1.lower().data(),s3.data(),outlineParser()->getLine());
  }
         [ LOOKAHEAD(generic_map_aspect()) generic_map_aspect() ]
         [ port_map_aspect() ] <SEMI_T>
@@ -774,7 +791,7 @@ concurrent_procedure_call_statement()
  /*
   catch( ParseException e )
   {
-    error_skipto(SEMI_T, "syntax error in declarative item");
+    outlineParser()->error_skipto(SEMI_T, "syntax error in declarative item");
   }
  */
 }
@@ -819,13 +836,13 @@ void configuration_declaration() :  {QCString s,s1;}
  <CONFIGURATION_T> s=identifier() <OF_T> s1=name() <IS_T>
   {
 
-  confName=s+"::"+s1;
-  addVhdlType(s.data(),getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
+  m_sharedState->confName=s+"::"+s1;
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
   }
     configuration_declarative_part()
     block_configuration()
  <END_T> [ <CONFIGURATION_T> ] [ name() ] <SEMI_T>
- { genLabels.resize(0); confName="";}
+ { m_sharedState->genLabels.resize(0); m_sharedState->confName="";}
 }
 
 void configuration_declarative_item() : {}
@@ -860,7 +877,7 @@ QCString constant_declaration() :  {QCString s,s1,s2;Token *t=0;}
      if(t)
       s2.prepend(":=");
      QCString it=s1+s2;
-     addVhdlType(s.data(),getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public);
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public);
      it.prepend("constant ");
      return it;
     }
@@ -961,8 +978,8 @@ QCString element_declaration() :  {QCString s,s1;}
 s=identifier_list() <COLON_T> s1=subtype_indication() <SEMI_T>
 {
 
-  addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s1.data(),Public);
-  //addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s1.data(),Public);
+  //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
   return s+":"+s1;
 }
 }
@@ -1011,17 +1028,17 @@ void entity_declaration() :  {QCString s;}
    // try{
     <ENTITY_T> s=identifier()  <IS_T>
              {
-                lastEntity=current.get();
-                lastCompound=0;
-                addVhdlType(s.data(),getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
+                m_sharedState->lastEntity=m_sharedState->current;
+                m_sharedState->lastCompound=0;
+                outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
                }
         entity_header()
         entity_declarative_part ()
       [ <BEGIN_T> entity_statement_part() ]
        <END_T> [ <ENTITY_T> ] [ name() ]
-     //    }catch(...){error_skipto(SEMI_T);}
+     //    }catch(...){outlineParser()->error_skipto(SEMI_T);}
      <SEMI_T>
-     { lastEntity=0;lastCompound=0; genLabels.resize(0); }
+     { m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0); }
 }
 
 void entity_declarative_item() : {}
@@ -1064,8 +1081,8 @@ s=entity_tag() [ s1=signature() ] { return s+s1;}
 
 void entity_header() : {}
 {
- [  { currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC; } generic_clause()]
- [ { currP=VhdlDocGen::PORT; } port_clause()]
+ [  { m_sharedState->currP=VhdlDocGen::GENERIC;m_sharedState->parse_sec=GEN_SEC; } generic_clause()]
+ [ { m_sharedState->currP=VhdlDocGen::PORT; } port_clause()]
 }
 
 QCString entity_name_list() :  {QCString s,s1;}
@@ -1120,7 +1137,7 @@ QCString exit_statement() :  {QCString s,s1,s2;Token *t=0;Token *t1=0;}
 [ s=identifier() t=<COLON_T> ] <EXIT_T> [ s1=identifier() ]
 [ t1=<WHEN_T> s2=condition() ] <SEMI_T>
 {
-  lab.resize(0);
+  m_sharedState->lab.resize(0);
   if(t) s+=":";
   if(t1) s2.prepend(" when ");
    FlowChart::addFlowChart(FlowChart::EXIT_NO,"exit",s2.data(),s1.data());
@@ -1162,7 +1179,7 @@ QCString file_declaration() :  {QCString s,s1,s2,s3;}
  <FILE_T> s=identifier_list() <COLON_T> s2=subtype_indication() [ s3=file_open_information() ] <SEMI_T>
    {
    QCString t1=s2+" "+s3;
-   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
+   outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
    return " file "+s+":"+s2+" "+s3+";";
    }
  }
@@ -1204,38 +1221,41 @@ QCString formal_part() : {QCString s,s1;}
 s=name() [<LPAREN_T> formal_designator() <RPAREN_T> {s+"("+s1+")";}] {return s;}
 }
 
-QCString full_type_declaration() :  {Entry *tmpEntry;QCString s,s1,s2;}
+QCString full_type_declaration() :  { std::shared_ptr<Entry> tmpEntry;QCString s,s1,s2; }
 {
-<TYPE_T> s=identifier() <IS_T>
-{
-  tmpEntry=current.get();
-  addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
-}
- try{
-     s2=type_definition()
-       }catch(...){error_skipto(SEMI_T);}
-     <SEMI_T>
-     {
-      if (s2.contains("#")) {
-        VhdlDocGen::deleteAllChars(s2,'#');
-        tmpEntry->spec=VhdlDocGen::RECORD;
-        tmpEntry->type=s2.data();
-        //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s2.data(),Public);
-      }
-      else if (s2.contains("%")) {
-        VhdlDocGen::deleteAllChars(s2,'%');
-        tmpEntry->spec=VhdlDocGen::UNITS;
-        tmpEntry->type=s2.data();
-        //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,s2.data(),s2.data(),Public);
-      }
-      else {
-        tmpEntry->spec=VhdlDocGen::TYPE;
-        tmpEntry->type=s2.data();
-        //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,s2.data(),Public);
-      }
-      tmpEntry=0;
-      return "type "+s+" is "+s2+";";
-     }
+  <TYPE_T> s=identifier() <IS_T>
+  {
+    tmpEntry=m_sharedState->current;
+    outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
+  }
+  try
+  {
+    s2=type_definition()
+  }
+  catch(...)
+  { outlineParser()->error_skipto(SEMI_T); }
+  <SEMI_T>
+  {
+    if (s2.contains("#")) {
+      VhdlDocGen::deleteAllChars(s2,'#');
+      tmpEntry->spec=VhdlDocGen::RECORD;
+      tmpEntry->type=s2.data();
+      //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s2.data(),Public);
+    }
+    else if (s2.contains("%")) {
+      VhdlDocGen::deleteAllChars(s2,'%');
+      tmpEntry->spec=VhdlDocGen::UNITS;
+      tmpEntry->type=s2.data();
+      //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,s2.data(),s2.data(),Public);
+    }
+    else {
+      tmpEntry->spec=VhdlDocGen::TYPE;
+      tmpEntry->type=s2.data();
+      //outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,s2.data(),Public);
+    }
+    tmpEntry.reset();
+    return "type "+s+" is "+s2+";";
+  }
 }
 
 QCString function_call() :  {QCString s,s1;}
@@ -1248,11 +1268,11 @@ void generate_statement() :  {QCString s;}
 s=identifier() <COLON_T>
           try{
         generate_scheme() <GENERATE_T>
-        { pushLabel(genLabels,s); }
+        { outlineParser()->pushLabel(m_sharedState->genLabels,s); }
           generate_statement_body1()
         <END_T>
-                 }catch(...){error_skipto(GENERATE_T);}
-        <GENERATE_T> [ identifier() ] <SEMI_T> {genLabels=popLabel(genLabels); }
+                 }catch(...){outlineParser()->error_skipto(GENERATE_T);}
+        <GENERATE_T> [ identifier() ] <SEMI_T> {m_sharedState->genLabels=outlineParser()->popLabel(m_sharedState->genLabels); }
 }
 
 void generate_scheme() : {}
@@ -1263,7 +1283,7 @@ void generate_scheme() : {}
 
 void generic_clause() : {QCString s;}
 {
- <GENERIC_T>  <LPAREN_T> { parse_sec=GEN_SEC; } s=generic_list() <RPAREN_T> <SEMI_T> { parse_sec=0; }
+ <GENERIC_T>  <LPAREN_T> { m_sharedState->parse_sec=GEN_SEC; } s=generic_list() <RPAREN_T> <SEMI_T> { m_sharedState->parse_sec=0; }
 }
 
 QCString generic_list() :  {QCString s;}
@@ -1321,30 +1341,30 @@ QCString identifier_list() : {QCString str,str1;}
 
 void if_statement() :  {QCString s,s1;}
 {
-[LOOKAHEAD(1) identifier() <COLON_T> ]
+  [LOOKAHEAD(1) identifier() <COLON_T> ]
     <IF_T> s=condition() <THEN_T>
     {
-    s.prepend("if ");
-    FlowChart::addFlowChart(FlowChart::IF_NO,0,s);
+      s.prepend("if ");
+      FlowChart::addFlowChart(FlowChart::IF_NO,0,s);
+    }
+  sequence_of_statement()
+    (
+     <ELSIF_T> s1=condition() <THEN_T>
+     {
+     s1.prepend("elsif ");
+     FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data());
+     }
+     sequence_of_statement()
+    )*
+    [LOOKAHEAD(1) <ELSE_T>
+    {
+      FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
+    }
+  sequence_of_statement() ] <END_T> <IF_T> [ identifier() ] <SEMI_T>
+  {
+    FlowChart::moveToPrevLevel();
+    FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
   }
-        sequence_of_statement()
-        (
-          <ELSIF_T> s1=condition() <THEN_T>
-          {
-           s1.prepend("elsif ");
-           FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data());
-          }
-          sequence_of_statement()
-        )*
-        [LOOKAHEAD(1) <ELSE_T>
-         {
-           FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
-         }
-        sequence_of_statement() ] <END_T> <IF_T> [ identifier() ] <SEMI_T>
-         {
-          FlowChart::moveToPrevLevel();
-          FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
-        }
 }
 
 QCString incomplete_type_declaration() :  {QCString s;}
@@ -1359,7 +1379,7 @@ QCString index_constraint() :  {QCString s="("; QCString s1,s2;}
 {
   //try{
   <LPAREN_T> s2=discrete_range(){s+=s2;}(LOOKAHEAD(1)<COMMA_T> s1=discrete_range(){s+=",";s+=s1;})*  <RPAREN_T> {return s+")";}
-//}catch(...){  error_skipto(SEMI_T);hasError=false;return "";}
+//}catch(...){  outlineParser()->error_skipto(SEMI_T);hasError=false;return "";}
   }
 
 QCString index_specification() : {QCString s;}
@@ -1417,68 +1437,67 @@ subprogram_declaration() { return s;}
 |
  s=object_class() s1=identifier()
  {
- if (parse_sec==GEN_SEC)
-    
-    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,s1.data(),0,Public);
-    return s;
-    }
+   if (m_sharedState->parse_sec==GEN_SEC)
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,s1.data(),0,Public);
+   return s;
+ }
 }
 
 QCString interface_element() :  {QCString s;}
 {
-s=interface_declaration(){ return s;}
+  s=interface_declaration(){ return s;}
 }
 
 QCString interface_file_declaration() : {QCString s,s1;}
 {
-<FILE_T> s=identifier_list() <COLON_T> s1=subtype_indication()
-{
-   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
-   return " file "+s+":"+s1;
-}
+  <FILE_T> s=identifier_list() <COLON_T> s1=subtype_indication()
+  {
+    outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
+    return " file "+s+":"+s1;
+  }
 }
 
 QCString interface_list() :  {QCString s,s1,s2;}
 {
-s=interface_element() (LOOKAHEAD(1) <SEMI_T> s1=interface_element(){s2+=";";s2+=s1;})* { return s+s2;}
+  s=interface_element() (LOOKAHEAD(1) <SEMI_T> s1=interface_element(){s2+=";";s2+=s1;})* { return s+s2;}
 }
 
 
 
 QCString interface_variable_declaration() :  {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;}
 {
-[( tok=<VARIABLE_T> | tok=<SIGNAL_T> | tok=<CONSTANT_T>|tok=<SHARED_T>) ]
-  s=identifier_list() <COLON_T> [ s1=mode() ]
-  s2=subtype_indication()  [ tok1=<BUS_T> ] [ tok2=<VARASSIGN_T> s4=expression() ]
-{
-                    if(tok)
-                    s5=tok->image.c_str();
+[ ( tok=<VARIABLE_T> | tok=<SIGNAL_T> | tok=<CONSTANT_T>|tok=<SHARED_T>) ]
+    s=identifier_list() <COLON_T> [ s1=mode() ]
+    s2=subtype_indication()  [ tok1=<BUS_T> ] [ tok2=<VARASSIGN_T> s4=expression() ]
+    {
+      if(tok)
+        s5=tok->image.c_str();
 
-                    if(tok1)
-                     s3=tok1->image.data();
+      if(tok1)
+        s3=tok1->image.data();
 
-                    if(tok2)
-                     s3+=":=";
+      if(tok2)
+        s3+=":=";
 
-                    QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4;
-                    if (currP!=VhdlDocGen::COMPONENT)
-                    {
-                      if (currP==VhdlDocGen::FUNCTION || currP==VhdlDocGen::PROCEDURE)
-                      {
-                        addProto(s5.data(),s.data(),s1.data(),s2.data(),s3.data(),s4.data());
-                      }
-                      else
-                      {
-                        QCString i=s2+s3+s4;
-                        if (currP==VhdlDocGen::GENERIC && param_sec==0)
-                          addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public);
-                        else if(parse_sec != GEN_SEC)
-                          addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public);
-                      }
-                      //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
-                    } // if component
-              return it;
-            }
+      QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4;
+      if (m_sharedState->currP!=VhdlDocGen::COMPONENT)
+      {
+        if (m_sharedState->currP==VhdlDocGen::FUNCTION || m_sharedState->currP==VhdlDocGen::PROCEDURE)
+        {
+          outlineParser()->addProto(s5.data(),s.data(),s1.data(),s2.data(),s3.data(),s4.data());
+        }
+        else
+        {
+          QCString i=s2+s3+s4;
+          if (m_sharedState->currP==VhdlDocGen::GENERIC && m_sharedState->param_sec==0)
+            outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,i.data(),s1.data(),Public);
+          else if(m_sharedState->parse_sec != GEN_SEC)
+            outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,i.data(),s1.data(),Public);
+        }
+        //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
+      } // if component
+      return it;
+    }
 }
 
 QCString iteration_scheme() :  {QCString s;}
@@ -1486,15 +1505,15 @@ QCString iteration_scheme() :  {QCString s;}
 <WHILE_T> s=condition()
 {
    s.prepend("while ");
-   FlowChart::addFlowChart(FlowChart::WHILE_NO,0,s.data(),lab.data());
-   lab="";
+   FlowChart::addFlowChart(FlowChart::WHILE_NO,0,s.data(),m_sharedState->lab.data());
+   m_sharedState->lab="";
   return s;
 }
 | <FOR_T> s=parameter_specification()
 {
-    QCString q=lab+" for "+s;
-    FlowChart::addFlowChart(FlowChart::FOR_NO,0,q.data(),lab.data());
-    lab="";
+    QCString q=m_sharedState->lab+" for "+s;
+    FlowChart::addFlowChart(FlowChart::FOR_NO,0,q.data(),m_sharedState->lab.data());
+    m_sharedState->lab="";
     return q;
 }
 }
@@ -1509,9 +1528,9 @@ QCString library_clause() :  {QCString s;}
  (<LIBRARY_T> s=identifier_list() <SEMI_T>
  )
  {
-               if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
+               if ( m_sharedState->parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
                    {
-                           addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
+                           outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
                    }
                    QCString s1="library "+s;
                    return s1;
@@ -1652,7 +1671,7 @@ QCString next_statement() :  {QCString s,s1,s2;Token *t=0;Token *t1=0;}
 {
   if(t) s+=":";
    FlowChart::addFlowChart(FlowChart::NEXT_NO,"next ",s2.data(),s1.data());
-    lab.resize(0);
+    m_sharedState->lab.resize(0);
   if(t1) s2.prepend("when ");
   return s+s1+s2+";";
 }
@@ -1695,13 +1714,13 @@ void package_body() :  {QCString s;}
 {
 <PACKAGE_T> <BODY_T> s=name() <IS_T>
  {
-                        lastCompound=current.get();
+                        m_sharedState->lastCompound=m_sharedState->current;
                         s.prepend("_");
-                        addVhdlType(s,getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
+                        outlineParser()->addVhdlType(s,outlineParser()->getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
                       }
  package_body_declarative_part()
 
-<END_T> [<PACKAGE_T> <BODY_T>  ] [ name() ] <SEMI_T> { lastCompound=0; genLabels.resize(0); }
+<END_T> [<PACKAGE_T> <BODY_T>  ] [ name() ] <SEMI_T> { m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0); }
 }
 
 void package_body_declarative_item() :  {}
@@ -1731,20 +1750,20 @@ void package_declaration():  {QCString s;}
 
  <PACKAGE_T> s=identifier() <IS_T>
                           {
-                          lastCompound=current.get();
-                          std::shared_ptr<Entry> clone=std::make_shared<Entry>(*current);
+                          m_sharedState->lastCompound=m_sharedState->current;
+                          std::shared_ptr<Entry> clone=std::make_shared<Entry>(*m_sharedState->current);
                           clone->section=Entry::NAMESPACE_SEC;
                           clone->spec=VhdlDocGen::PACKAGE;
                           clone->name=s;
-                          clone->startLine=getLine(PACKAGE_T);
-                          clone->bodyLine=getLine(PACKAGE_T);
+                          clone->startLine=outlineParser()->getLine(PACKAGE_T);
+                          clone->bodyLine=outlineParser()->getLine(PACKAGE_T);
                           clone->protection=Package;
-                          current_root->moveToSubEntryAndKeep(clone);
-                          addVhdlType(s,getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
+                          m_sharedState->current_root->moveToSubEntryAndKeep(clone);
+                          outlineParser()->addVhdlType(s,outlineParser()->getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
                           }
     package_declarative_part()
 <END_T> [ <PACKAGE_T>] [ name() ] <SEMI_T>
-{ lastEntity=0;lastCompound=0; genLabels.resize(0); }
+{ m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0); }
 }
 
 void geninter():{}
@@ -1800,7 +1819,7 @@ QCString physical_literal() :  {QCString s,s1;}
 QCString physical_type_definition() : {QCString s,s1,s2;}
 {
         <UNITS_T>
-            s=identifier()<SEMI_T> { addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);}
+            s=identifier()<SEMI_T> { outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);}
             (
              s1=secondary_unit_declaration()
             )*
@@ -1811,7 +1830,7 @@ QCString physical_type_definition() : {QCString s,s1,s2;}
 
 void port_clause() :  {}
 {
-   <PORT_T> <LPAREN_T>  port_list()<RPAREN_T>  <SEMI_T>{ currP=0; }
+   <PORT_T> <LPAREN_T>  port_list()<RPAREN_T>  <SEMI_T>{ m_sharedState->currP=0; }
 }
 
 QCString port_list() : {QCString s;}
@@ -1909,9 +1928,9 @@ void process_statement() : {QCString s,s1,s2;Token *tok=0;}
 [ s=identifier() <COLON_T> ]
 [ <POSTPONED_T> ]
  {
-               currP=VhdlDocGen::PROCESS;
-               current->startLine=getLine();
-               current->bodyLine=getLine();
+               m_sharedState->currP=VhdlDocGen::PROCESS;
+               m_sharedState->current->startLine=outlineParser()->getLine();
+               m_sharedState->current->bodyLine=outlineParser()->getLine();
   }
  <PROCESS_T>
  //try{
@@ -1925,25 +1944,25 @@ void process_statement() : {QCString s,s1,s2;Token *tok=0;}
         <BEGIN_T>
         process_statement_part()
         <END_T> [ <POSTPONED_T> ]
-         // }catch(...){error_skipto(PROCESS_T);}
+         // }catch(...){outlineParser()->error_skipto(PROCESS_T);}
         <PROCESS_T> [ identifier() ] <SEMI_T>
- {
-  if(s.isEmpty())
-   currName=VhdlDocGen::getProcessNumber();
-   else
-   currName=s;
-
-   current->name=currName;
-   tempEntry=current.get();
-   current->endBodyLine=getLine();
-   currP=0;
- if(tok)
-   s1=tok->image.data();
-  createFunction(currName,VhdlDocGen::PROCESS,s1.data());
-  createFlow();
-   currName="";
-   newEntry();
-}
+        {
+          if(s.isEmpty())
+            m_sharedState->currName=VhdlDocGen::getProcessNumber();
+          else
+            m_sharedState->currName=s;
+
+          m_sharedState->current->name=m_sharedState->currName;
+          m_sharedState->tempEntry=m_sharedState->current;
+          m_sharedState->current->endBodyLine=outlineParser()->getLine();
+          m_sharedState->currP=0;
+          if(tok)
+            s1=tok->image.data();
+          outlineParser()->createFunction(m_sharedState->currName,VhdlDocGen::PROCESS,s1.data());
+          outlineParser()->createFlow();
+          m_sharedState->currName="";
+          outlineParser()->newEntry();
+        }
 }
 
 void process_statement_part() :  {}
@@ -1981,7 +2000,7 @@ void record_type_definition() : {}
     <RECORD_T>
      //  try{
        (element_declaration())+
-            //    }catch(...){error_skipto(END_T);}
+            //    }catch(...){outlineParser()->error_skipto(END_T);}
        <END_T>
        <RECORD_T> [ name()]
 }
@@ -2038,8 +2057,8 @@ QCString secondary_unit_declaration() :  {QCString s,s1;}
 {
 s=identifier() <EQU_T> s1=physical_literal() <SEMI_T>
 {
-  //printf("\n %s %s [%d]",s.data(),s1.data(),getLine());
-  addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
+  //printf("\n %s %s [%d]",s.data(),s1.data(),outlineParser()->getLine());
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
 
   return s+"="+s1; }
 }
@@ -2172,7 +2191,7 @@ void signal_declaration() :  { Token* tok=0;QCString s,s1,s2,s3,s4;}
      if(tok)
       s3.prepend(":=");
      s4=s1+s2+s3;
-     addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
+     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
      }
 }
 QCString signal_kind() :  {}
@@ -2230,14 +2249,14 @@ tok=<STRINGLITERAL> {return tok->image.c_str();}
       }
       FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0);
     }
- // }catch(...){error_skipto(BEGIN_T);}
+ // }catch(...){outlineParser()->error_skipto(BEGIN_T);}
 <BEGIN_T>
 subprogram_statement_part()
 <END_T> [ subprogram_kind() ] [ designator() ] <SEMI_T>
  {
-      tempEntry->endBodyLine=getLine(END_T);
-      createFlow();
-      currP=0;
+      m_sharedState->tempEntry->endBodyLine=outlineParser()->getLine(END_T);
+      outlineParser()->createFlow();
+      m_sharedState->currP=0;
     }
 }
 
@@ -2246,7 +2265,7 @@ void subprogram_declaration() :  {}
 LOOKAHEAD(subprogram_instantiation_declaration())
 subprogram_instantiation_declaration()
 |
-subprogram_specification()subprogram_1(){currP=0;}
+subprogram_specification()subprogram_1(){m_sharedState->currP=0;}
 }
 
 void subprogram_1() :  {}
@@ -2292,35 +2311,35 @@ void subprogram_specification() : {QCString s;Token *tok=0;Token *t;}
 {
  <PROCEDURE_T> s=designator()
  {
-              currP=VhdlDocGen::PROCEDURE;
-              createFunction(s.data(),currP,0);
-              tempEntry=current.get();
-               current->startLine=getLine(PROCEDURE_T);
-               current->bodyLine=getLine(PROCEDURE_T);
-
-              } [LOOKAHEAD(1) <LPAREN_T> { param_sec=PARAM_SEC; } interface_list() { param_sec=0; }<RPAREN_T> ]
-             [LOOKAHEAD(2) gen_interface_list()]
-             [ LOOKAHEAD(2) gen_assoc_list()]
-             param()
-              {  newEntry(); }
-|
+   m_sharedState->currP=VhdlDocGen::PROCEDURE;
+   outlineParser()->createFunction(s.data(),m_sharedState->currP,0);
+   m_sharedState->tempEntry=m_sharedState->current;
+   m_sharedState->current->startLine=outlineParser()->getLine(PROCEDURE_T);
+   m_sharedState->current->bodyLine=outlineParser()->getLine(PROCEDURE_T);
+
+ } [LOOKAHEAD(1) <LPAREN_T> { m_sharedState->param_sec=PARAM_SEC; } interface_list() { m_sharedState->param_sec=0; }<RPAREN_T> ]
+   [LOOKAHEAD(2) gen_interface_list()]
+   [ LOOKAHEAD(2) gen_assoc_list()]
+   param()
+ {  outlineParser()->newEntry(); }
+ |
  [ (tok=<PURE_T> | tok=<IMPURE_T>) ] t=<FUNCTION_T> s=designator()
-  {
-     currP=VhdlDocGen::FUNCTION;
-     if(tok)
-     createFunction(tok->image.c_str(),currP,s.data());
-     else
-     createFunction(0,currP,s.data());
-      tempEntry=current.get();
-      current->startLine=getLine(FUNCTION_T);
-      current->bodyLine=getLine(FUNCTION_T);
-  }
- [{ param_sec=PARAM_SEC; } <LPAREN_T> formal_parameter_list() <RPAREN_T> { param_sec=0; }]
+ {
+   m_sharedState->currP=VhdlDocGen::FUNCTION;
+   if(tok)
+     outlineParser()->createFunction(tok->image.c_str(),m_sharedState->currP,s.data());
+   else
+     outlineParser()->createFunction(0,m_sharedState->currP,s.data());
+   m_sharedState->tempEntry=m_sharedState->current;
+   m_sharedState->current->startLine=outlineParser()->getLine(FUNCTION_T);
+   m_sharedState->current->bodyLine=outlineParser()->getLine(FUNCTION_T);
+ }
+ [{ m_sharedState->param_sec=PARAM_SEC; } <LPAREN_T> formal_parameter_list() <RPAREN_T> { m_sharedState->param_sec=0; }]
     <RETURN_T> s=type_mark()
              {
-                tempEntry=current.get();
-                current->type=s;
-                newEntry();
+                m_sharedState->tempEntry=m_sharedState->current;
+                m_sharedState->current->type=s;
+                outlineParser()->newEntry();
               }
 }
 
@@ -2332,20 +2351,20 @@ void subprogram_statement_part() : {}
 QCString subtype_declaration() :  {QCString s,s1;}
 {
 <SUBTYPE_T> s=identifier() <IS_T> s1=subtype_indication() <SEMI_T>
-  {
-  addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
+{
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
   return " subtype "+s+" is "+s1+";";
-  }
+}
 }
 
 QCString subtype_indication() :  {QCString s,s1,s2;}
 {
  s=name()
  [LOOKAHEAD (name()) s1=name()] [LOOKAHEAD(constraint() ) s2=constraint()]
- {return s+" "+s1+" "+s2;}
+ { return s+" "+s1+" "+s2; }
 }
 
-QCString suffix() :  {QCString s;}
+QCString suffix() :  { QCString s; }
 {
 LOOKAHEAD(name())
 s=name() { return s;}
@@ -2354,18 +2373,18 @@ s=name() { return s;}
 | <ALL_T> {return " all ";}
 }
 
-QCString target() :  {QCString s;}
+QCString target() :  { QCString s; }
 {
  s=name(){ return s;}
 | s=aggregate() { return s;}
 }
 
-QCString term() : {QCString s,s1,s2;}
+QCString term() : { QCString s,s1,s2; }
 {
  s=factor() ( LOOKAHEAD(2) s1=multiplying_operation() s2=factor(){s+=s1;s+=s2;} )* { return s;}
 }
 
-QCString timeout_clause() : {QCString s;}
+QCString timeout_clause() : { QCString s; }
 {
 <FOR_T>  s=expression()
 {
@@ -2396,7 +2415,7 @@ s=scalar_type_definition(){ return s;}
  LOOKAHEAD(2)
  protected_type_body()            { return ""; }
 | protected_type_declaration()     { return ""; }
-//}catch(...){error_skipto(SEMI_T); return "";}
+//}catch(...){outlineParser()->error_skipto(SEMI_T); return "";}
 }
 
 QCString type_mark() : {QCString s; }
@@ -2419,9 +2438,9 @@ QCString unconstraint_array_definition() :  {QCString s,s1,s2,s3;}
                    {
                      QCStringList ql=QCStringList::split(".",ql1[j]);
                      QCString it=ql[1];
-                     if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
+                     if ( m_sharedState->parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
                      {
-                       VhdlParser::addVhdlType(it.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),"_use_",Public);
+                       outlineParser()->addVhdlType(it.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),"_use_",Public);
                      }
                    }
                    s1="use "+s;
@@ -2444,27 +2463,28 @@ QCString variable_declaration() :  {Token *tok=0;Token *t1=0;QCString s,s1,s2;}
 [ t1=<VARASSIGN_T> s2=expression() ] <SEMI_T>
 
 {
-    int spec;
-    if(t1)
-     s2.prepend(":=");
-    QCString val=" variable "+s+":"+s1+s2+";";
-    QCString it=s1;
-    if(tok != 0)
-    {
-     it.prepend(" shared ");
-     val.prepend(" shared");
-     spec=VhdlDocGen::SHAREDVARIABLE;
-     }
-     else
-     spec=VhdlDocGen::SHAREDVARIABLE;
+  int spec;
+  if(t1)
+    s2.prepend(":=");
+  QCString val=" variable "+s+":"+s1+s2+";";
+  QCString it=s1;
+  if(tok != 0)
+  {
+    it.prepend(" shared ");
+    val.prepend(" shared");
+    spec=VhdlDocGen::SHAREDVARIABLE;
+  }
+  else
+    spec=VhdlDocGen::SHAREDVARIABLE;
 
-    if(t1){
-     it+=":=";
-     it+=s2;
-     }
-    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
-    return val;
- }
+  if(t1)
+  {
+    it+=":=";
+    it+=s2;
+  }
+  outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
+  return val;
+}
 
 }
 
@@ -2502,7 +2522,7 @@ QCString protected_type_body() :{ }
    <PROTECTED_T> <BODY_T>
           protected_type_body_declarative_part()
 
-    //}catch(...){error_skipto(END_T);}
+    //}catch(...){outlineParser()->error_skipto(END_T);}
     <END_T><PROTECTED_T> <BODY_T>   [identifier()]  {return "";}
 }
 
@@ -2538,7 +2558,7 @@ QCString protected_type_declaration() : {  }
    <PROTECTED_T>
         try{
           protected_type_declarative_part()
-        }catch(...){error_skipto(END_T);}
+        }catch(...){outlineParser()->error_skipto(END_T);}
        <END_T><PROTECTED_T> [ identifier() ] { return "";}
  }
 
@@ -2569,10 +2589,10 @@ QCString context_ref() : {QCString s;}
 
 void context_declaration(): {QCString s,s1;}
 {
- <CONTEXT_T> s=identifier() <IS_T> { parse_sec=CONTEXT_SEC; }  (s1=libustcont_stats())* <END_T> [ <CONTEXT_T> ][identifier()] <SEMI_T>
+ <CONTEXT_T> s=identifier() <IS_T> { m_sharedState->parse_sec=CONTEXT_SEC; }  (s1=libustcont_stats())* <END_T> [ <CONTEXT_T> ][identifier()] <SEMI_T>
                         {
-                          parse_sec=0;
-                          addVhdlType(s.data(),getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
+                          m_sharedState->parse_sec=0;
+                          outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
                         }
 }
 
@@ -2588,7 +2608,7 @@ QCString libustcont_stats(): {QCString s;}
  <PACKAGE_T> s=identifier() <IS_T>  <NEW_T> s1=name() s2=signature() [gen_assoc_list()] <SEMI_T>
     {
       QCString q=" is new "+s1+s2;
-      addVhdlType(s.data(),getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
+      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
     }
 }
 
@@ -2596,7 +2616,7 @@ QCString interface_package_declaration(): {QCString s,s1;}
 {
  <PACKAGE_T> s=identifier() <IS_T> <NEW_T> s1=name() [gen_assoc_list()]
                         {
-                          current->name=s;
+                          m_sharedState->current->name=s;
                             return "package "+s+" is new "+s1;
                          }
 }
@@ -2606,7 +2626,7 @@ QCString subprogram_instantiation_declaration():{QCString s,s1,s2;}
  <FUNCTION_T>  s=identifier() <IS_T> <NEW_T> s1=name()  s2=signature() [gen_assoc_list()] <SEMI_T>
     {
      QCString q= " is new "+s1+s2;
-      addVhdlType(s.data(),getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
+      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
     return q;
     }
 }
@@ -2622,12 +2642,12 @@ void gen_interface_list() : {}
    <GENERIC_T><LPAREN_T>
                         {
                           //int u=s_str.iLine;
-                          parse_sec=GEN_SEC;
+                          m_sharedState->parse_sec=GEN_SEC;
                         }
                         interface_list()
                         {
                         //  QCString vo=$3;
-                          parse_sec=0;
+                          m_sharedState->parse_sec=0;
                         }
                         <RPAREN_T>
 }
@@ -2719,86 +2739,93 @@ QCString pathname_element ():{QCString s,s1;}
 
 QCString pathname_element_list():{QCString s,s1,s2;}
 {
-        ( s=pathname_element() <DOT_T> ) {s+=".";} (LOOKAHEAD(pathname_element() <DOT_T>) s1=pathname_element() <DOT_T> {s2+=s1;s2+="."; })*
-        { return s+s2; }
+  ( s=pathname_element() <DOT_T> ) {s+=".";} (LOOKAHEAD(pathname_element() <DOT_T>) s1=pathname_element() <DOT_T> {s2+=s1;s2+="."; })*
+  { return s+s2; }
 }
 
 QCString package_path_name():{QCString s;}
 {
- <AT_T> s=name() { return "@"+s; }
+  <AT_T> s=name() { return "@"+s; }
 }
 
 void conditional_signal_assignment_wave(): {}
 {
   LOOKAHEAD(conditional_force_assignment())
-  conditional_force_assignment()
-  |conditional_waveform_assignment()
+  conditional_force_assignment() |
+  conditional_waveform_assignment()
 }
 
 void conditional_waveform_assignment():{}
 {
- target() <LESSTHAN_T> [LOOKAHEAD(1) delay_mechanism() ] waveform_element() <WHEN_T> expression() [else_wave_list()] <SEMI_T>
- }
+  target()
+  <LESSTHAN_T> [LOOKAHEAD(1) delay_mechanism() ] waveform_element()
+  <WHEN_T> expression() [else_wave_list()]
+  <SEMI_T>
+}
 
 void  else_wave_list(): {}
 {
-<ELSE_T> expression() [ <WHEN_T> expression()]
+  <ELSE_T> expression() [ <WHEN_T> expression()]
 }
 
 void conditional_force_assignment(): {}
 {
- target()  <LESSTHAN_T> <FORCE_T>  [inout_stat()] expression() <WHEN_T> [expression() else_stat()] <SEMI_T>
+  target()
+  <LESSTHAN_T>
+  <FORCE_T>  [inout_stat()] expression()
+  <WHEN_T> [expression() else_stat()]
+  <SEMI_T>
 }
 
 void selected_signal_assignment_wave() : {}
 {
- LOOKAHEAD(selected_force_assignment() )
- selected_force_assignment()
-| selected_waveform_assignment()
+  LOOKAHEAD(selected_force_assignment() )
+  selected_force_assignment() |
+  selected_waveform_assignment()
 }
 
 void selected_variable_assignment():{}
 {
-  <WITH_T> expression() <SELECT_T> [<Q_T>] select_name() <VARASSIGN_T> sel_var_list() // { $$=""; }
+  <WITH_T> expression()
+  <SELECT_T> [<Q_T>] select_name()
+  <VARASSIGN_T> sel_var_list() // { $$=""; }
 }
 
 void select_name(): {}
 {
- LOOKAHEAD(aggregate())
- aggregate()
-  | name()
-
+  LOOKAHEAD(aggregate())
+  aggregate() |
+  name()
 }
 
 void selected_waveform_assignment():{}
 {
- <WITH_T> expression() <SELECT_T>  [<Q_T>]
-   target() <LESSTHAN_T> [delay_mechanism()] sel_wave_list()
+  <WITH_T> expression()
+  <SELECT_T> [<Q_T>] target()
+  <LESSTHAN_T> [delay_mechanism()] sel_wave_list()
 }
 
 void selected_force_assignment():{}
 {
-<WITH_T> expression() <SELECT_T> [<Q_T>] target() <LESSTHAN_T> <FORCE_T>
+  <WITH_T> expression() <SELECT_T> [<Q_T>] target() <LESSTHAN_T> <FORCE_T>
                                                   [inout_stat()] sel_var_list()
 }
 
 void sel_var_list(): {}
 {
   (expression() <WHEN_T> choices() (<COMMA_T>|<SEMI_T>))(LOOKAHEAD(expression() <WHEN_T>) expression() <WHEN_T> choices() (<COMMA_T>|<SEMI_T>))*
-
 }
 
 
 void sel_wave_list() : {}
 {
    waveform_element() <WHEN_T> choices() (LOOKAHEAD(1) <COMMA_T> sel_wave_list())* <SEMI_T>
-  // |  sel_wave_list_1()
 }
 
 void inout_stat(): {}
 {
-  <IN_T>
- | <OUT_T>
+  <IN_T> |
+  <OUT_T>
  }
 
 void else_stat(): {}
@@ -2810,68 +2837,64 @@ void else_stat(): {}
 
 QCString interface_subprogram_declaration(): {QCString s;}
 {
-  s=iproc()  { return s;}
+   s=iproc()  { return s;}
  | s=ifunc()  { return s; }
 }
 
 QCString iproc(): {QCString s,s1;}
- {
+{
   <PROCEDURE_T> s=identifier()  s1=param()
   {
-  current->name=s;
-  return "procedure "+s+s1;
+    m_sharedState->current->name=s;
+    return "procedure "+s+s1;
   }
- }
+}
 
 QCString ifunc():{QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;}
 {
-
  [t=<PURE_T> | t=<IMPURE_T> ] <FUNCTION_T>  s=name() s1=param() <RETURN_T> s2=name() [t1=<IS_T> (s3=identifier() | t2=<BOX_T>)]
-    {
-      QCString q;
-      if(t) q=t->image.data();
-      if(t2) s3="<>";
-      if (!s3.isEmpty())
-      {
-        s3.prepend(" is ");
-      }
-     current->name=s;
-    if (parse_sec==GEN_SEC)
-                    {
-                      QCString ss=q+" function "+s1+" return "+s2+s3;
-                      int a=getLine(FUNCTION_T);
-                      int b=getLine(PROCEDURE_T);
-
-                      if (a>b) b=a;
-                      addVhdlType(current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public);
-                    }
-         currP=0;return "";
-       }
+ {
+   QCString q;
+   if(t) q=t->image.data();
+   if(t2) s3="<>";
+   if (!s3.isEmpty())
+   {
+     s3.prepend(" is ");
+   }
+   m_sharedState->current->name=s;
+   if (m_sharedState->parse_sec==GEN_SEC)
+   {
+     QCString ss=q+" function "+s1+" return "+s2+s3;
+     int a=outlineParser()->getLine(FUNCTION_T);
+     int b=outlineParser()->getLine(PROCEDURE_T);
 
-    }
+     if (a>b) b=a;
+     outlineParser()->addVhdlType(m_sharedState->current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public);
+   }
+   m_sharedState->currP=0;return "";
+ }
+}
 
 
 QCString param(): {QCString s,s1;Token *tok=0;}
 {
-[ tok=<PARAMETER_T> ] { param_sec=PARAM_SEC; }
-                  [ <LPAREN_T>  s1=interface_list() <RPAREN_T>]
-                   {
-                       if(tok)
-                     {
-                      s = tok->image.data();
-
-                    }
-                      param_sec=0;
-                      return s+"("+s1+")";
-                    }
-
- }
+  [ tok=<PARAMETER_T> ] { m_sharedState->param_sec=PARAM_SEC; }
+  [ <LPAREN_T>  s1=interface_list() <RPAREN_T>]
+  {
+    if(tok)
+    {
+      s = tok->image.data();
+    }
+    m_sharedState->param_sec=0;
+    return s+"("+s1+")";
+  }
+}
 
  // -----------------------------------------------------------------
  // needed for inline (function/process/procedure) parsing
 
 void parseInline() :  {}
 {
- process_statement()
- | subprogram_declaration()
- }
+  process_statement() |
+  subprogram_declaration()
+}