Refactoring: modernize Doxygen::symbolMap

Author: doxygen

addon/doxyapp/doxyapp.cpp

@@ -148,25 +148,9 @@ static void listSymbol(Definition *d)
 
 static void listSymbols()
 {
-  QDictIterator<DefinitionIntf> sli(*Doxygen::symbolMap);
-  DefinitionIntf *di;
-  for (sli.toFirst();(di=sli.current());++sli)
+  for (const auto &kv : Doxygen::symbolMap)
   {
-    if (di->definitionType()==DefinitionIntf::TypeSymbolList) // list of symbols
-      // with same name
-    {
-      DefinitionListIterator dli(*(DefinitionList*)di);
-      Definition *d;
-      // for each symbol
-      for (dli.toFirst();(d=dli.current());++dli)
-      {
-        listSymbol(d);
-      }
-    }
-    else // single symbol
-    {
-      listSymbol((Definition*)di);
-    }
+    listSymbol(kv.second);
   }
 }
 
@@ -223,25 +207,14 @@ static void lookupSymbols(const QCString &sym)
 {
   if (!sym.isEmpty())
   {
-    DefinitionIntf *di = Doxygen::symbolMap->find(sym);
-    if (di)
+    auto range = Doxygen::symbolMap.find(sym);
+    bool found=false;
+    for (auto it=range.first; it!=range.second; ++it)
     {
-      if (di->definitionType()==DefinitionIntf::TypeSymbolList)
-      {
-        DefinitionListIterator dli(*(DefinitionList*)di);
-        Definition *d;
-        // for each symbol with the given name
-        for (dli.toFirst();(d=dli.current());++dli)
-        {
-          lookupSymbol(d);
-        }
-      }
-      else
-      {
-        lookupSymbol((Definition*)di);
-      }
+      lookupSymbol(it->second);
+      found=true;
     }
-    else
+    if (!found)
     {
       printf("Unknown symbol\n");
     }

src/context.cpp

@@ -10309,25 +10309,9 @@ void generateOutputViaTemplate()
       }
 
       // clear all cached data in Definition objects.
-      QDictIterator<DefinitionIntf> di(*Doxygen::symbolMap);
-      const DefinitionIntf *intf;
-      for (;(intf=di.current());++di)
+      for (const auto &kv : Doxygen::symbolMap)
       {
-        if (intf->definitionType()==DefinitionIntf::TypeSymbolList) // list of symbols
-        {
-          DefinitionListIterator dli(*dynamic_cast<const DefinitionList*>(intf));
-          const Definition *d;
-          // for each symbol
-          for (dli.toFirst();(d=dli.current());++dli)
-          {
-            d->setCookie(0);
-          }
-        }
-        else // single symbol
-        {
-          const Definition *d = dynamic_cast<const Definition *>(intf);
-          d->setCookie(0);
-        }
+        kv.second->setCookie(0);
       }
 
       e.destroyContext(ctx);

src/definition.cpp

@@ -224,73 +224,15 @@ static void addToMap(const char *name,Definition *d)
   if (!vhdlOpt && index!=-1) symbolName=symbolName.mid(index+2);
   if (!symbolName.isEmpty())
   {
-    //printf("******* adding symbol '%s' (%p)\n",symbolName.data(),d);
-    DefinitionIntf *di=Doxygen::symbolMap->find(symbolName);
-    //printf("  addToMap(%p): looking for symbol %s: %p\n",d,symbolName.data(),di);
-    if (di==0) // new Symbol
-    {
-      //printf("  new symbol!\n");
-      Doxygen::symbolMap->insert(symbolName,d);
-    }
-    else // existing symbol
-    {
-      //printf("  existing symbol: ");
-      if (di->definitionType()==DefinitionIntf::TypeSymbolList) // already multiple symbols
-      {
-        //printf("adding to exiting list\n");
-        DefinitionList *dl = (DefinitionList*)di;
-        dl->append(d);
-      }
-      else // going from one to two symbols
-      {
-        Doxygen::symbolMap->take(symbolName);
-        DefinitionList *dl = new DefinitionList;
-        //printf("replacing symbol by list %p with elements %p and %p\n",dl,di,d);
-        dl->append((Definition*)di);
-        dl->append(d);
-        Doxygen::symbolMap->insert(symbolName,dl);
-      }
-    }
-
-    // auto resize if needed
-    static int sizeIndex=9;
-    if (Doxygen::symbolMap->size()>SDict_primes[sizeIndex])
-    {
-      Doxygen::symbolMap->resize(SDict_primes[++sizeIndex]);
-    }
+    Doxygen::symbolMap.add(symbolName,d);
 
     d->_setSymbolName(symbolName);
   }
 }
 
 static void removeFromMap(Definition *d)
 {
-  QCString symbolName = d->_symbolName();
-  if (!symbolName.isEmpty())
-  {
-    //printf("******* removing symbol '%s' (%p)\n",symbolName.data(),d);
-    DefinitionIntf *di=Doxygen::symbolMap->find(symbolName);
-    if (di)
-    {
-      if (di!=d) // symbolName not unique
-      {
-        //printf("  removing from list: %p!\n",di);
-        DefinitionList *dl = (DefinitionList*)di;
-        bool b = dl->removeRef(d);
-        ASSERT(b==TRUE);
-        if (dl->isEmpty())
-        {
-          Doxygen::symbolMap->take(symbolName);
-          delete dl;
-        }
-      }
-      else // symbolName unique
-      {
-        //printf("  removing symbol %p\n",di);
-        Doxygen::symbolMap->take(symbolName);
-      }
-    }
-  }
+  Doxygen::symbolMap.remove(d->_symbolName(),d);
 }
 
 DefinitionImpl::DefinitionImpl(const char *df,int dl,int dc,

src/doxygen.cpp

@@ -142,7 +142,7 @@ bool             Doxygen::insideMainPage = FALSE; // are we generating docs for
 NamespaceDef    *Doxygen::globalScope = 0;
 bool             Doxygen::parseSourcesNeeded = FALSE;
 SearchIndexIntf *Doxygen::searchIndex=0;
-QDict<DefinitionIntf> *Doxygen::symbolMap = 0;
+SymbolMap<Definition> Doxygen::symbolMap;
 QDict<Definition> *Doxygen::clangUsrMap = 0;
 bool             Doxygen::outputToWizard=FALSE;
 QDict<int> *     Doxygen::htmlDirMap = 0;
@@ -2429,7 +2429,8 @@ static bool isVarWithConstructor(const Entry *root)
   static QRegExp initChars("[0-9\"'&*!^]+");
   static QRegExp idChars("[a-z_A-Z][a-z_A-Z0-9]*");
   bool result=FALSE;
-  bool typeIsClass;
+  bool typeIsClass = false;
+  bool typePtrType = false;
   QCString type;
   Definition *ctx = 0;
   FileDef *fd = 0;
@@ -2462,11 +2463,15 @@ static bool isVarWithConstructor(const Entry *root)
   findAndRemoveWord(type,"const");
   findAndRemoveWord(type,"static");
   findAndRemoveWord(type,"volatile");
+  typePtrType = type.find('*')!=-1 || type.find('&')!=-1;
   //if (type.left(6)=="const ") type=type.right(type.length()-6);
-  typeIsClass=getResolvedClass(ctx,fd,type)!=0;
-  if (!typeIsClass && (ti=type.find('<'))!=-1)
+  if (!typePtrType)
   {
-    typeIsClass=getResolvedClass(ctx,fd,type.left(ti))!=0;
+    typeIsClass = getResolvedClass(ctx,fd,type)!=0;
+    if (!typeIsClass && (ti=type.find('<'))!=-1)
+    {
+      typeIsClass=getResolvedClass(ctx,fd,type.left(ti))!=0;
+    }
   }
   if (typeIsClass) // now we still have to check if the arguments are
                    // types or values. Since we do not have complete type info
@@ -2492,6 +2497,14 @@ static bool isVarWithConstructor(const Entry *root)
         }
         goto done;
       }
+      if (!a.type.isEmpty() &&
+          (a.type.at(a.type.length()-1)=='*' ||
+           a.type.at(a.type.length()-1)=='&'))
+           // type ends with * or & => pointer or reference
+      {
+        result=FALSE;
+        goto done;
+      }
       if (a.type.isEmpty() || getResolvedClass(ctx,fd,a.type)!=0)
       {
         result=FALSE; // arg type is a known type
@@ -2503,13 +2516,6 @@ static bool isVarWithConstructor(const Entry *root)
          result=FALSE; // argument is a typedef
          goto done;
       }
-      if (a.type.at(a.type.length()-1)=='*' ||
-          a.type.at(a.type.length()-1)=='&')
-                     // type ends with * or & => pointer or reference
-      {
-        result=FALSE;
-        goto done;
-      }
       if (a.type.find(initChars)==0)
       {
         result=TRUE; // argument type starts with typical initializer char
@@ -7812,25 +7818,9 @@ static void sortMemberLists()
 
 void computeTooltipTexts()
 {
-  QDictIterator<DefinitionIntf> di(*Doxygen::symbolMap);
-  DefinitionIntf *intf;
-  for (;(intf=di.current());++di)
+  for (const auto &kv : Doxygen::symbolMap)
   {
-    if (intf->definitionType()==DefinitionIntf::TypeSymbolList) // list of symbols
-    {
-      DefinitionListIterator dli(*(DefinitionList*)intf);
-      Definition *d;
-      // for each symbol
-      for (dli.toFirst();(d=dli.current());++dli)
-      {
-        d->computeTooltip();
-      }
-    }
-    else // single symbol
-    {
-      Definition *d = (Definition *)intf;
-      if (d!=Doxygen::globalScope) d->computeTooltip();
-    }
+    kv.second->computeTooltip();
   }
 }
 
@@ -9796,25 +9786,9 @@ static void dumpSymbolMap()
   if (f.open(IO_WriteOnly))
   {
     FTextStream t(&f);
-    QDictIterator<DefinitionIntf> di(*Doxygen::symbolMap);
-    DefinitionIntf *intf;
-    for (;(intf=di.current());++di)
+    for (const auto &kv : Doxygen::symbolMap)
     {
-      if (intf->definitionType()==DefinitionIntf::TypeSymbolList) // list of symbols
-      {
-        DefinitionListIterator dli(*(DefinitionList*)intf);
-        Definition *d;
-        // for each symbol
-        for (dli.toFirst();(d=dli.current());++dli)
-        {
-          dumpSymbol(t,d);
-        }
-      }
-      else // single symbol
-      {
-        Definition *d = (Definition *)intf;
-        if (d!=Doxygen::globalScope) dumpSymbol(t,d);
-      }
+      dumpSymbol(t,kv.second);
     }
   }
 }
@@ -9939,7 +9913,6 @@ void initDoxygen()
   initNamespaceMemberIndices();
   initFileMemberIndices();
 
-  Doxygen::symbolMap     = new QDict<DefinitionIntf>(50177);
 #ifdef USE_LIBCLANG
   Doxygen::clangUsrMap   = new QDict<Definition>(50177);
 #endif
@@ -10012,26 +9985,6 @@ void cleanUpDoxygen()
   delete g_outputList;
   Mappers::freeMappers();
 
-  if (Doxygen::symbolMap)
-  {
-    // iterate through Doxygen::symbolMap and delete all
-    // DefinitionList objects, since they have no owner
-    QDictIterator<DefinitionIntf> dli(*Doxygen::symbolMap);
-    DefinitionIntf *di;
-    for (dli.toFirst();(di=dli.current());)
-    {
-      if (di->definitionType()==DefinitionIntf::TypeSymbolList)
-      {
-        DefinitionIntf *tmp = Doxygen::symbolMap->take(dli.currentKey());
-        delete (DefinitionList *)tmp;
-      }
-      else
-      {
-        ++dli;
-      }
-    }
-  }
-
   delete Doxygen::memberNameLinkedMap;
   delete Doxygen::functionNameLinkedMap;
   delete Doxygen::groupSDict;
@@ -10041,11 +9994,6 @@ void cleanUpDoxygen()
   delete Doxygen::directories;
 
   DotManager::deleteInstance();
-
-  //delete Doxygen::symbolMap; <- we cannot do this unless all static lists
-  //                              (such as Doxygen::namespaceSDict)
-  //                              with objects based on Definition are made
-  //                              dynamic first
 }
 
 static int computeIdealCacheParam(uint v)
@@ -11811,7 +11759,6 @@ void generateOutput()
   thisDir.remove(Doxygen::filterDBFileName);
   Config::deinit();
   QTextCodec::deleteAllCodecs();
-  delete Doxygen::symbolMap;
   delete Doxygen::clangUsrMap;
   g_successfulRun=TRUE;
 }

src/doxygen.h

@@ -29,6 +29,7 @@
 #include "memberlist.h"
 #include "define.h"
 #include "cache.h"
+#include "symbolmap.h"
 
 #define THREAD_LOCAL thread_local
 #define AtomicInt    std::atomic_int
@@ -66,8 +67,6 @@ struct MemberGroupInfo;
 
 typedef QList<QCString>    StringList;
 typedef QListIterator<QCString>    StringListIterator;
-//typedef QDict<FileDef>     FileDict;
-//typedef QDict<GroupDef>    GroupDict;
 
 class StringDict : public QDict<QCString>
 {
@@ -123,7 +122,7 @@ class Doxygen
     static QCString                  htmlFileExtension;
     static bool                      parseSourcesNeeded;
     static SearchIndexIntf          *searchIndex;
-    static QDict<DefinitionIntf>    *symbolMap;
+    static SymbolMap<Definition>     symbolMap;
     static QDict<Definition>        *clangUsrMap;
     static bool                      outputToWizard;
     static QDict<int>               *htmlDirMap;

src/pycode.l

@@ -1490,22 +1490,10 @@ static void findMemberLink(yyscan_t yyscanner,
   //    );
   if (yyextra->currentDefinition)
   {
-    DefinitionIntf *di = Doxygen::symbolMap->find(symName);
-    if (di)
+    auto range = Doxygen::symbolMap.find(symName);
+    for (auto it = range.first; it!=range.second; ++it)
     {
-      if (di->definitionType()==DefinitionIntf::TypeSymbolList) // multiple symbols
-      {
-        DefinitionListIterator dli(*(DefinitionList*)di);
-        Definition *sym;
-        for (dli.toFirst();(sym=dli.current());++dli)
-        {
-          if (findMemberLink(yyscanner,ol,sym,symName)) return;
-        }
-      }
-      else // single symbol
-      {
-        if (findMemberLink(yyscanner,ol,(Definition*)di,symName)) return;
-      }
+      findMemberLink(yyscanner,ol,it->second,symName);
     }
   }
   //printf("sym %s not found\n",&yytext[5]);