Use smartpointers to manage the lifetime of Entry objects

1 files changed, 48 insertions, 57 deletions

diff --git a/src/vhdljjparser.cpp b/src/vhdljjparser.cpp
index aeed048..9a817dc 100644
--- a/src/vhdljjparser.cpp
+++ b/src/vhdljjparser.cpp
@@ -48,16 +48,16 @@ static Entry* oldEntry;
 static bool varr=FALSE;
 static QCString varName;
 
-static QList<Entry> instFiles;
-static QList<Entry> libUse;
-static QList<Entry> lineEntry;
+static std::vector< std::unique_ptr<Entry> > instFiles;
+static std::vector< std::unique_ptr<Entry> > libUse;
+static std::vector<Entry*> lineEntry;
 
 Entry*   VhdlParser::currentCompound=0;
 Entry*   VhdlParser::tempEntry=0;
 Entry*   VhdlParser::lastEntity=0  ;
 Entry*   VhdlParser::lastCompound=0  ;
-Entry*   VhdlParser::current=0;
 Entry*   VhdlParser::current_root  = 0;
+std::unique_ptr<Entry> VhdlParser::current=0;
 QCString VhdlParser::compSpec;
 QCString VhdlParser::currName;
 QCString VhdlParser::confName;
@@ -84,13 +84,13 @@ static QCString strComment;
 static int iCodeLen;
 static const char *vhdlFileName = 0;
 
-bool  checkMultiComment(QCString& qcs,int line);
-QList<Entry>* getEntryAtLine(const Entry* ce,int line);
+static bool checkMultiComment(QCString& qcs,int line);
+static void insertEntryAtLine(const Entry* ce,int line);
 
 //-------------------------------------
 
-QList<VhdlConfNode>& getVhdlConfiguration() { return  configL; }
-QList<Entry>& getVhdlInstList() { return  instFiles; }
+const QList<VhdlConfNode>& getVhdlConfiguration() { return  configL; }
+const std::vector<std::unique_ptr<Entry> > &getVhdlInstList() { return  instFiles; }
 
 Entry* getVhdlCompound()
 {
@@ -105,8 +105,8 @@ bool isConstraintFile(const QCString &fileName,const QCString &ext)
 }
 
 
-void VHDLLanguageScanner::parseInput(const char *fileName,const char *fileBuf,Entry *root,
-                          bool ,QStrList&)
+void VHDLLanguageScanner::parseInput(const char *fileName,const char *fileBuf,
+                          const std::unique_ptr<Entry> &root, bool ,QStrList&)
 {
   g_thisParser=this;
   bool inLine=false;
@@ -128,34 +128,32 @@ void VHDLLanguageScanner::parseInput(const char *fileName,const char *fileBuf,En
 
   if (xilinx_ucf)
   {
-    VhdlDocGen::parseUCF(fileBuf,root,yyFileName,FALSE);
+    VhdlDocGen::parseUCF(fileBuf,root.get(),yyFileName,FALSE);
     return;
   }
   if (altera_qsf)
   {
-    VhdlDocGen::parseUCF(fileBuf,root,yyFileName,TRUE);
+    VhdlDocGen::parseUCF(fileBuf,root.get(),yyFileName,TRUE);
     return;
   }
-  libUse.setAutoDelete(true);
   yyLineNr=1;
-  VhdlParser::current_root=root;
+  VhdlParser::current_root=root.get();
   VhdlParser::lastCompound=0;
   VhdlParser::lastEntity=0;
   VhdlParser::currentCompound=0;
   VhdlParser::lastEntity=0;
   oldEntry = 0;
-  VhdlParser::current=new Entry();
-  VhdlParser::initEntry(VhdlParser::current);
+  VhdlParser::current=std::make_unique<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);
 
-  delete VhdlParser::current;
-  VhdlParser::current=0;
+  VhdlParser::current.reset();
 
   if (!inLine)
-  VhdlParser::mapLibPackage(root);
+  VhdlParser::mapLibPackage(root.get());
 
   delete[] lineParse;
   yyFileName.resize(0);
@@ -198,34 +196,33 @@ void VhdlParser::initEntry(Entry *e)
 
 void VhdlParser::newEntry()
 {
+  previous = current.get();
   if (current->spec==VhdlDocGen::ENTITY ||
       current->spec==VhdlDocGen::PACKAGE ||
       current->spec==VhdlDocGen::ARCHITECTURE ||
       current->spec==VhdlDocGen::PACKAGE_BODY)
   {
-    current_root->addSubEntry(current);
+    current_root->moveToSubEntryAndRefresh(current);
   }
   else
   {
     if (lastCompound)
     {
-      lastCompound->addSubEntry(current);
+      lastCompound->moveToSubEntryAndRefresh(current);
     }
     else
     {
       if (lastEntity)
       {
-	lastEntity->addSubEntry(current);
+	lastEntity->moveToSubEntryAndRefresh(current);
       }
       else
       {
-	current_root->addSubEntry(current);
+	current_root->moveToSubEntryAndRefresh(current);
       }
     }
   }
-  previous = current;
-  current = new Entry ;
-  initEntry(current);
+  initEntry(current.get());
 }
 
 void VhdlParser::handleFlowComment(const char* doc)
@@ -259,7 +256,7 @@ void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
 
   Protection protection=Public;
 
-  if (oldEntry==current)
+  if (oldEntry==current.get())
   {
     //printf("\n find pending message  < %s > at line: %d \n ",doc.data(),iDocLine);
     str_doc.doc=doc;
@@ -269,7 +266,7 @@ void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
     return;
   }
 
-  oldEntry=current;
+  oldEntry=current.get();
 
   if (brief)
   {
@@ -293,7 +290,7 @@ void VhdlParser::handleCommentBlock(const char* doc1,bool brief)
   QCString processedDoc = preprocessCommentBlock(doc,yyFileName,iDocLine);
   while (parseCommentBlock(
         g_thisParser,
-        current,
+        current.get(),
         processedDoc, // text
         yyFileName, // file
         iDocLine,   // line of block start
@@ -357,13 +354,11 @@ void VhdlParser::addCompInst(const char *n, const char* instName, const char* co
     current->args=lastCompound->name;
     if (true) // !findInstant(current->type))
     {
-      initEntry(current);
-      instFiles.append(new Entry(*current));
+      initEntry(current.get());
+      instFiles.emplace_back(std::make_unique<Entry>(*current));
     }
 
-    Entry *temp=current;  // hold  current pointer  (temp=oldEntry)
-    current=new Entry;     // (oldEntry != current)
-    delete  temp;
+    current=std::make_unique<Entry>();
   }
   else
   {
@@ -401,7 +396,7 @@ void VhdlParser::addVhdlType(const char *n,int startLine,int section,
 
     if (!lastCompound && (section==Entry::VARIABLE_SEC) &&  (spec == VhdlDocGen::USE || spec == VhdlDocGen::LIBRARY) )
     {
-      libUse.append(new Entry(*current));
+      libUse.emplace_back(std::make_unique<Entry>(*current));
       current->reset();
     }
     newEntry();
@@ -590,31 +585,30 @@ void VhdlParser::addProto(const char *s1,const char *s2,const char *s3,
  */
 void VhdlParser::mapLibPackage( Entry* root)
 {
-  QList<Entry> epp=libUse;
-  EntryListIterator eli(epp);
-  Entry *rt;
-  for (;(rt=eli.current());++eli)
+  //QList<Entry> epp=libUse;
+  //EntryListIterator eli(epp);
+  //Entry *rt;
+  //for (;(rt=eli.current());++eli)
+  for (const auto &rt : libUse)
   {
     if (addLibUseClause(rt->name))
     {
-      Entry *current;
-      EntryListIterator eLib(*root->children());
       bool bFound=FALSE;
-      for (eLib.toFirst();(current=eLib.current());++eLib)
+      for (const auto &current : root->children())
       {
-        if (VhdlDocGen::isVhdlClass(current))
+        if (VhdlDocGen::isVhdlClass(current.get()))
         {
           if (current->startLine > rt->startLine)
           {
             bFound=TRUE;
-            current->addSubEntry(new Entry(*rt));
+            current->copyToSubEntry(rt);
             break;
           }
         }
       }//for
       if (!bFound)
       {
-        root->addSubEntry(new Entry(*rt));
+        root->copyToSubEntry(rt);
       }
     } //if
   }// for
@@ -718,37 +712,34 @@ void VhdlParser::oneLineComment(QCString qcs)
 
 bool  checkMultiComment(QCString& qcs,int line)
 {
-  QList<Entry> *pTemp=getEntryAtLine(VhdlParser::current_root,line);
+  insertEntryAtLine(VhdlParser::current_root,line);
 
-  if (pTemp->isEmpty()) return false;
+  if (lineEntry.empty()) return false;
 
   VhdlDocGen::prepareComment(qcs);
-  while (!pTemp->isEmpty())
+  while (!lineEntry.empty())
   {
-    Entry *e=(Entry*)pTemp->getFirst();
+    Entry *e=lineEntry.back();
     e->briefLine=line;
     e->brief+=qcs;
 
-    pTemp->removeFirst();
+    lineEntry.pop_back();
   }
   return true;
 }
 
 // returns the vhdl parsed types at line xxx
-QList<Entry>* getEntryAtLine(const Entry* ce,int line)
+void insertEntryAtLine(const Entry* ce,int line)
 {
-  EntryListIterator eli(*ce->children());
-  Entry *rt;
-  for (;(rt=eli.current());++eli)
+  for (const auto &rt : ce->children())
   {
     if (rt->bodyLine==line)
     {
-      lineEntry.insert(0,rt);
+      lineEntry.push_back(rt.get());
     }
 
-    getEntryAtLine(rt,line);
+    insertEntryAtLine(rt.get(),line);
   }
-  return &lineEntry;
 }
 
 const char *getVhdlFileName(void)