issue #10797 Spurious links generated for C++ keywords and template parameters

doxygen · doxygen · commit 0a7e798132bf · 2024-04-16T19:35:11.000+02:00
diff --git a/src/pycode.l b/src/pycode.l
@@ -1545,8 +1545,8 @@ static void findMemberLink(yyscan_t yyscanner,
   bool found = false;
   if (yyextra->currentDefinition)
   {
-    auto v = Doxygen::symbolMap->find(symName);
-    for (auto p : v)
+    const auto &v = Doxygen::symbolMap->find(symName);
+    for (const auto &p : v)
     {
       if (findMemberLink(yyscanner,ol,p,symName)) found = true;
     }
diff --git a/src/sqlite3gen.cpp b/src/sqlite3gen.cpp
@@ -834,15 +834,15 @@ class TextGeneratorSqlite3Impl : public TextGeneratorIntf
 {
   public:
     TextGeneratorSqlite3Impl(StringVector &l) : m_list(l) { }
-    void writeString(const QCString & /*s*/,bool /*keepSpaces*/) const override
+    void writeString(std::string_view /*s*/,bool /*keepSpaces*/) const override
     {
     }
     void writeBreak(int) const override
     {
       DBG_CTX(("writeBreak\n"));
     }
     void writeLink(const QCString & /*extRef*/,const QCString &file,
-                   const QCString &anchor,const QCString & /*text*/
+                   const QCString &anchor,std::string_view /*text*/
                   ) const override
     {
       std::string rs = file.str();
diff --git a/src/symbolmap.h b/src/symbolmap.h
@@ -21,6 +21,7 @@
 #include <vector>
 #include <string>
 #include <utility>
+#include <cassert>
 
 //! Class implementing a symbol map that maps symbol names to objects.
 //! Symbol names do not have to be unique.
@@ -46,37 +47,34 @@ class SymbolMap
       }
       else
       {
-        m_map.emplace(std::make_pair(name.str(),VectorPtr({def})));
+        m_map.emplace(name.str(),VectorPtr({def}));
       }
     }
 
     //! Remove a symbol \a def from the map that was stored under key \a name
     void remove(const QCString &name,Ptr def)
     {
-      VectorPtr &v = find(name);
-      auto it = std::find(v.begin(),v.end(),def);
-      if (it!=v.end())
+      auto it1 = m_map.find(name.str());
+      if (it1!=m_map.end())
       {
-        v.erase(it);
-        if (v.empty())
+        VectorPtr &v = it1->second;
+        auto it2 = std::find(v.begin(),v.end(),def);
+        if (it2!=v.end())
         {
-          m_map.erase(name.str());
+          v.erase(it2);
+          if (v.empty())
+          {
+            m_map.erase(it1);
+          }
         }
       }
     }
 
     //! Find the list of symbols stored under key \a name
     //! Returns a pair of iterators pointing to the start and end of the range of matching symbols
-    const VectorPtr &find(const QCString &name) const
-    {
-      auto it = m_map.find(name.str());
-      return it==m_map.end() ? m_noMatch : it->second;
-    }
-
-    //! Find the list of symbols stored under key \a name
-    //! Returns a pair of iterators pointing to the start and end of the range of matching symbols
-    VectorPtr &find(const QCString &name)
+    const VectorPtr &find(const QCString &name)
     {
+      assert(m_noMatch.empty());
       auto it = m_map.find(name.str());
       return it==m_map.end() ? m_noMatch : it->second;
     }
diff --git a/src/symbolresolver.cpp b/src/symbolresolver.cpp
@@ -411,29 +411,15 @@ const Definition *SymbolResolver::Private::getResolvedSymbolRec(
     return nullptr; // empty name
   }
 
-  auto &range = Doxygen::symbolMap->find(name);
+  int i;
+  const auto &range1 = Doxygen::symbolMap->find(name);
+  const auto &range  = range1.empty() && (i=name.find('<')!=-1) ? Doxygen::symbolMap->find(name.left(i)) : range1;
   if (range.empty())
   {
-    int i;
-    if (insideCode && (i=name.find('<'))!=-1)
-    {
-      range = Doxygen::symbolMap->find(name.left(i));
-      if (range.empty())
-      {
-        AUTO_TRACE_ADD("no symbols (including unspecialized)");
-        return nullptr;
-      }
-    }
-    else
-    {
-      AUTO_TRACE_ADD("no symbols");
-      return nullptr;
-    }
-  }
-  else
-  {
-    AUTO_TRACE_ADD("{} candidates",range.size());
+    AUTO_TRACE_ADD("no symbols (including unspecialized)");
+    return nullptr;
   }
+  AUTO_TRACE_ADD("{} -> {} candidates",name,range.size());
 
   bool hasUsingStatements =
     (m_fileScope && (!m_fileScope->getUsedNamespaces().empty() ||
diff --git a/src/util.cpp b/src/util.cpp
@@ -104,28 +104,32 @@ TextGeneratorOLImpl::TextGeneratorOLImpl(OutputList &ol) : m_ol(ol)
 {
 }
 
-void TextGeneratorOLImpl::writeString(const QCString &s,bool keepSpaces) const
+void TextGeneratorOLImpl::writeString(std::string_view s,bool keepSpaces) const
 {
-  if (s.isEmpty()) return;
+  if (s.empty()) return;
   //printf("TextGeneratorOlImpl::writeString('%s',%d)\n",s,keepSpaces);
   if (keepSpaces)
   {
-    const char *p=s.data();
-    if (p)
+    char cs[2];
+    char c;
+    cs[1]='\0';
+    for (size_t i=0;i<s.length();i++)
     {
-      char cs[2];
-      char c;
-      cs[1]='\0';
-      while ((c=*p++))
+      c = s[i];
+      if (c==' ')
+      {
+        m_ol.writeNonBreakableSpace(1);
+      }
+      else
       {
-        if (c==' ') m_ol.writeNonBreakableSpace(1);
-        else cs[0]=c,m_ol.docify(cs);
+        cs[0]=c;
+        m_ol.docify(cs);
       }
     }
   }
   else
   {
-    m_ol.docify(s);
+    m_ol.docify(QCString(s));
   }
 }
 
@@ -140,11 +144,11 @@ void TextGeneratorOLImpl::writeBreak(int indent) const
 }
 
 void TextGeneratorOLImpl::writeLink(const QCString &extRef,const QCString &file,
-                                    const QCString &anchor,const QCString &text
+                                    const QCString &anchor,std::string_view text
                                    ) const
 {
   //printf("TextGeneratorOlImpl::writeLink('%s')\n",text);
-  m_ol.writeObjectLink(extRef,file,anchor,text);
+  m_ol.writeObjectLink(extRef,file,anchor,QCString(text));
 }
 
 //------------------------------------------------------------------------
@@ -892,15 +896,15 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
 {
   if (text.isEmpty()) return;
   //printf("linkify='%s'\n",qPrint(text));
-  std::string txtStr=text.str();
+  std::string_view txtStr=text.view();
   size_t strLen = txtStr.length();
   if (strLen==0) return;
 
   static const reg::Ex regExp(R"((::)?\a[\w~!\\.:$"]*)");
   reg::Iterator it(txtStr,regExp);
   reg::Iterator end;
 
-  //printf("linkifyText scope=%s fileScope=%s strtxt=%s strlen=%d external=%d\n",
+  //printf("linkifyText scope=%s fileScope=%s strtxt=%s strlen=%zu external=%d\n",
   //    scope ? qPrint(scope->name()):"<none>",
   //    fileScope ? qPrint(fileScope->name()) : "<none>",
   //    qPrint(txtStr),strLen,external);
@@ -915,8 +919,8 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
     floatingIndex+=newIndex-skipIndex+matchLen;
     if (newIndex>0 && txtStr.at(newIndex-1)=='0') // ignore hex numbers (match x00 in 0x00)
     {
-      std::string part = txtStr.substr(skipIndex,newIndex+matchLen-skipIndex);
-      out.writeString(part.c_str(),keepSpaces);
+      std::string_view part = txtStr.substr(skipIndex,newIndex+matchLen-skipIndex);
+      out.writeString(part,keepSpaces);
       skipIndex=index=newIndex+matchLen;
       continue;
     }
@@ -932,7 +936,7 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
     //printf("floatingIndex=%d strlen=%d autoBreak=%d\n",floatingIndex,strLen,autoBreak);
     if (strLen>35 && floatingIndex>30 && autoBreak) // try to insert a split point
     {
-      std::string splitText = txtStr.substr(skipIndex,newIndex-skipIndex);
+      std::string_view splitText = txtStr.substr(skipIndex,newIndex-skipIndex);
       size_t splitLength = splitText.length();
       size_t offset=1;
       size_t i = splitText.find(',');
@@ -942,26 +946,26 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
       //printf("splitText=[%s] len=%d i=%d offset=%d\n",qPrint(splitText),splitLength,i,offset);
       if (i!=std::string::npos) // add a link-break at i in case of Html output
       {
-        std::string part1 = splitText.substr(0,i+offset);
-        out.writeString(part1.c_str(),keepSpaces);
+        std::string_view part1 = splitText.substr(0,i+offset);
+        out.writeString(part1,keepSpaces);
         out.writeBreak(indentLevel==0 ? 0 : indentLevel+1);
-        std::string part2 = splitText.substr(i+offset);
-        out.writeString(part2.c_str(),keepSpaces);
+        std::string_view part2 = splitText.substr(i+offset);
+        out.writeString(part2,keepSpaces);
         floatingIndex=splitLength-i-offset+matchLen;
       }
       else
       {
-        out.writeString(splitText.c_str(),keepSpaces);
+        out.writeString(splitText,keepSpaces);
       }
     }
     else
     {
       //ol.docify(txtStr.mid(skipIndex,newIndex-skipIndex));
-      std::string part = txtStr.substr(skipIndex,newIndex-skipIndex);
-      out.writeString(part.c_str(),keepSpaces);
+      std::string_view part = txtStr.substr(skipIndex,newIndex-skipIndex);
+      out.writeString(part,keepSpaces);
     }
     // get word from string
-    std::string word=txtStr.substr(newIndex,matchLen);
+    std::string_view word=txtStr.substr(newIndex,matchLen);
     QCString matchWord = substitute(substitute(QCString(word),"\\","::"),".","::");
     //printf("linkifyText word=%s matchWord=%s scope=%s\n",
     //    qPrint(word),qPrint(matchWord),scope ? qPrint(scope->name()) : "<none>");
@@ -977,15 +981,15 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
       const MemberDef *typeDef = resolver.getTypedef();
       if (typeDef) // First look at typedef then class, see bug 584184.
       {
-        //printf("Found typedef %s\n",qPrint(typeDef->name()));
         if (external ? typeDef->isLinkable() : typeDef->isLinkableInProject())
         {
           if (typeDef->getOuterScope()!=self)
           {
+            //printf("Found typedef %s word='%s'\n",qPrint(typeDef->name()),qPrint(word));
             out.writeLink(typeDef->getReference(),
                 typeDef->getOutputFileBase(),
                 typeDef->anchor(),
-                word.c_str());
+                word);
             found=TRUE;
           }
         }
@@ -995,14 +999,14 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
         {
           if (self==nullptr || cd_->qualifiedName()!=self->qualifiedName())
           {
-            out.writeLink(cd_->getReference(),cd_->getOutputFileBase(),cd_->anchor(),word.c_str());
+            //printf("Found compound %s word='%s'\n",qPrint(cd->name()),qPrint(word));
+            out.writeLink(cd_->getReference(),cd_->getOutputFileBase(),cd_->anchor(),word);
             found=TRUE;
           }
         }
       };
       if (!found && (cd || (cd=getClass(matchWord))))
       {
-        //printf("Found class %s\n",qPrint(cd->name()));
         writeCompoundName(cd);
       }
       else if ((cd=getClass(matchWord+"-p"))) // search for Obj-C protocols as well
@@ -1035,7 +1039,7 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
       }
 
       //printf("ScopeName=%s\n",qPrint(scopeName));
-      //if (!found) printf("Trying to link %s in %s\n",qPrint(word),qPrint(scopeName));
+      //if (!found) printf("Trying to link '%s' in '%s'\n",qPrint(word),qPrint(scopeName));
       if (!found)
       {
         GetDefInput input(scopeName,matchWord,QCString());
@@ -1060,9 +1064,9 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
                 )
                )
             {
+              //printf("found symbol %s word='%s'\n",qPrint(result.md->name()),qPrint(word));
               out.writeLink(result.md->getReference(),result.md->getOutputFileBase(),
-                  result.md->anchor(),word.c_str());
-              //printf("found symbol %s\n",qPrint(matchWord));
+                  result.md->anchor(),word);
               found=TRUE;
             }
           }
@@ -1072,16 +1076,16 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
 
     if (!found) // add word to the result
     {
-      out.writeString(word.c_str(),keepSpaces);
+      out.writeString(word,keepSpaces);
     }
     // set next start point in the string
     //printf("index=%d/%d\n",index,txtStr.length());
     skipIndex=index=newIndex+matchLen;
   }
   // add last part of the string to the result.
   //ol.docify(txtStr.right(txtStr.length()-skipIndex));
-  std::string lastPart = txtStr.substr(skipIndex);
-  out.writeString(lastPart.c_str(),keepSpaces);
+  std::string_view lastPart = txtStr.substr(skipIndex);
+  out.writeString(lastPart,keepSpaces);
 }
 
 void writeMarkerList(OutputList &ol,const std::string &markerText,size_t numMarkers,
diff --git a/src/util.h b/src/util.h
@@ -26,6 +26,7 @@
 #include <functional>
 #include <fstream>
 #include <variant>
+#include <string_view>
 
 #include <ctype.h>
 #include "types.h"
@@ -64,10 +65,10 @@ class TextGeneratorIntf
   public:
     ABSTRACT_BASE_CLASS(TextGeneratorIntf)
 
-    virtual void writeString(const QCString &,bool) const = 0;
+    virtual void writeString(std::string_view,bool) const = 0;
     virtual void writeBreak(int indent) const = 0;
     virtual void writeLink(const QCString &extRef,const QCString &file,
-                      const QCString &anchor,const QCString &text
+                      const QCString &anchor,std::string_view text
                      ) const = 0;
 };
 
@@ -76,10 +77,10 @@ class TextGeneratorOLImpl : public TextGeneratorIntf
 {
   public:
     TextGeneratorOLImpl(OutputList &ol);
-    void writeString(const QCString &s,bool keepSpaces) const override;
+    void writeString(std::string_view s,bool keepSpaces) const override;
     void writeBreak(int indent) const override;
     void writeLink(const QCString &extRef,const QCString &file,
-                   const QCString &anchor,const QCString &text
+                   const QCString &anchor,std::string_view text
                   ) const override;
   private:
     OutputList &m_ol;
diff --git a/src/xmlgen.cpp b/src/xmlgen.cpp
@@ -212,16 +212,16 @@ class TextGeneratorXMLImpl : public TextGeneratorIntf
 {
   public:
     TextGeneratorXMLImpl(TextStream &t): m_t(t) {}
-    void writeString(const QCString &s,bool /*keepSpaces*/) const override
+    void writeString(std::string_view s,bool /*keepSpaces*/) const override
     {
-      writeXMLString(m_t,s);
+      writeXMLString(m_t,QCString(s));
     }
     void writeBreak(int) const override {}
     void writeLink(const QCString &extRef,const QCString &file,
-                   const QCString &anchor,const QCString &text
+                   const QCString &anchor,std::string_view text
                   ) const override
     {
-      writeXMLLink(m_t,extRef,file,anchor,text,QCString());
+      writeXMLLink(m_t,extRef,file,anchor,QCString(text),QCString());
     }
   private:
     TextStream &m_t;

Original file line number	Diff line number	Diff line change
`@@ -1545,8 +1545,8 @@ static void findMemberLink(yyscan_t yyscanner,`
`1545`	`1545`	`bool found = false;`
`1546`	`1546`	`if (yyextra->currentDefinition)`
`1547`	`1547`	`{`
`1548`		`- auto v = Doxygen::symbolMap->find(symName);`
`1549`		`- for (auto p : v)`
	`1548`	`+ const auto &v = Doxygen::symbolMap->find(symName);`
	`1549`	`+ for (const auto &p : v)`
`1550`	`1550`	`{`
`1551`	`1551`	`if (findMemberLink(yyscanner,ol,p,symName)) found = true;`
`1552`	`1552`	`}`
Original file line number	Diff line number	Diff line change
`@@ -834,15 +834,15 @@ class TextGeneratorSqlite3Impl : public TextGeneratorIntf`
`834`	`834`	`{`
`835`	`835`	`public:`
`836`	`836`	`TextGeneratorSqlite3Impl(StringVector &l) : m_list(l) { }`
`837`		`- void writeString(const QCString & /s/,bool /keepSpaces/) const override`
	`837`	`+ void writeString(std::string_view /s/,bool /keepSpaces/) const override`
`838`	`838`	`{`
`839`	`839`	`}`
`840`	`840`	`void writeBreak(int) const override`
`841`	`841`	`{`
`842`	`842`	`DBG_CTX(("writeBreak\n"));`
`843`	`843`	`}`
`844`	`844`	`void writeLink(const QCString & /extRef/,const QCString &file,`
`845`		`- const QCString &anchor,const QCString & /text/`
	`845`	`+ const QCString &anchor,std::string_view /text/`
`846`	`846`	`) const override`
`847`	`847`	`{`
`848`	`848`	`std::string rs = file.str();`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`#include <vector>`
`22`	`22`	`#include <string>`
`23`	`23`	`#include <utility>`
	`24`	`+#include <cassert>`
`24`	`25`
`25`	`26`	`//! Class implementing a symbol map that maps symbol names to objects.`
`26`	`27`	`//! Symbol names do not have to be unique.`
`@@ -46,37 +47,34 @@ class SymbolMap`
`46`	`47`	`}`
`47`	`48`	`else`
`48`	`49`	`{`
`49`		`- m_map.emplace(std::make_pair(name.str(),VectorPtr({def})));`
	`50`	`+ m_map.emplace(name.str(),VectorPtr({def}));`
`50`	`51`	`}`
`51`	`52`	`}`
`52`	`53`
`53`	`54`	`//! Remove a symbol \a def from the map that was stored under key \a name`
`54`	`55`	`void remove(const QCString &name,Ptr def)`
`55`	`56`	`{`
`56`		`- VectorPtr &v = find(name);`
`57`		`- auto it = std::find(v.begin(),v.end(),def);`
`58`		`- if (it!=v.end())`
	`57`	`+ auto it1 = m_map.find(name.str());`
	`58`	`+ if (it1!=m_map.end())`
`59`	`59`	`{`
`60`		`- v.erase(it);`
`61`		`- if (v.empty())`
	`60`	`+ VectorPtr &v = it1->second;`
	`61`	`+ auto it2 = std::find(v.begin(),v.end(),def);`
	`62`	`+ if (it2!=v.end())`
`62`	`63`	`{`
`63`		`- m_map.erase(name.str());`
	`64`	`+ v.erase(it2);`
	`65`	`+ if (v.empty())`
	`66`	`+ {`
	`67`	`+ m_map.erase(it1);`
	`68`	`+ }`
`64`	`69`	`}`
`65`	`70`	`}`
`66`	`71`	`}`
`67`	`72`
`68`	`73`	`//! Find the list of symbols stored under key \a name`
`69`	`74`	`//! Returns a pair of iterators pointing to the start and end of the range of matching symbols`
`70`		`- const VectorPtr &find(const QCString &name) const`
`71`		`- {`
`72`		`- auto it = m_map.find(name.str());`
`73`		`- return it==m_map.end() ? m_noMatch : it->second;`
`74`		`- }`
`75`		`-`
`76`		`- //! Find the list of symbols stored under key \a name`
`77`		`- //! Returns a pair of iterators pointing to the start and end of the range of matching symbols`
`78`		`- VectorPtr &find(const QCString &name)`
	`75`	`+ const VectorPtr &find(const QCString &name)`
`79`	`76`	`{`
	`77`	`+ assert(m_noMatch.empty());`
`80`	`78`	`auto it = m_map.find(name.str());`
`81`	`79`	`return it==m_map.end() ? m_noMatch : it->second;`
`82`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,28 +104,32 @@ TextGeneratorOLImpl::TextGeneratorOLImpl(OutputList &ol) : m_ol(ol)`
`104`	`104`	`{`
`105`	`105`	`}`
`106`	`106`
`107`		`-void TextGeneratorOLImpl::writeString(const QCString &s,bool keepSpaces) const`
	`107`	`+void TextGeneratorOLImpl::writeString(std::string_view s,bool keepSpaces) const`
`108`	`108`	`{`
`109`		`- if (s.isEmpty()) return;`
	`109`	`+ if (s.empty()) return;`
`110`	`110`	`//printf("TextGeneratorOlImpl::writeString('%s',%d)\n",s,keepSpaces);`
`111`	`111`	`if (keepSpaces)`
`112`	`112`	`{`
`113`		`- const char *p=s.data();`
`114`		`- if (p)`
	`113`	`+ char cs[2];`
	`114`	`+ char c;`
	`115`	`+ cs[1]='\0';`
	`116`	`+ for (size_t i=0;i<s.length();i++)`
`115`	`117`	`{`
`116`		`- char cs[2];`
`117`		`- char c;`
`118`		`- cs[1]='\0';`
`119`		`- while ((c=*p++))`
	`118`	`+ c = s[i];`
	`119`	`+ if (c==' ')`
	`120`	`+ {`
	`121`	`+ m_ol.writeNonBreakableSpace(1);`
	`122`	`+ }`
	`123`	`+ else`
`120`	`124`	`{`
`121`		`- if (c==' ') m_ol.writeNonBreakableSpace(1);`
`122`		`- else cs[0]=c,m_ol.docify(cs);`
	`125`	`+ cs[0]=c;`
	`126`	`+ m_ol.docify(cs);`
`123`	`127`	`}`
`124`	`128`	`}`
`125`	`129`	`}`
`126`	`130`	`else`
`127`	`131`	`{`
`128`		`- m_ol.docify(s);`
	`132`	`+ m_ol.docify(QCString(s));`
`129`	`133`	`}`
`130`	`134`	`}`
`131`	`135`
`@@ -140,11 +144,11 @@ void TextGeneratorOLImpl::writeBreak(int indent) const`
`140`	`144`	`}`
`141`	`145`
`142`	`146`	`void TextGeneratorOLImpl::writeLink(const QCString &extRef,const QCString &file,`
`143`		`- const QCString &anchor,const QCString &text`
	`147`	`+ const QCString &anchor,std::string_view text`
`144`	`148`	`) const`
`145`	`149`	`{`
`146`	`150`	`//printf("TextGeneratorOlImpl::writeLink('%s')\n",text);`
`147`		`- m_ol.writeObjectLink(extRef,file,anchor,text);`
	`151`	`+ m_ol.writeObjectLink(extRef,file,anchor,QCString(text));`
`148`	`152`	`}`
`149`	`153`
`150`	`154`	`//------------------------------------------------------------------------`
`@@ -892,15 +896,15 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`892`	`896`	`{`
`893`	`897`	`if (text.isEmpty()) return;`
`894`	`898`	`//printf("linkify='%s'\n",qPrint(text));`
`895`		`- std::string txtStr=text.str();`
	`899`	`+ std::string_view txtStr=text.view();`
`896`	`900`	`size_t strLen = txtStr.length();`
`897`	`901`	`if (strLen==0) return;`
`898`	`902`
`899`	`903`	`static const reg::Ex regExp(R"((::)?\a[\w~!\\.:$"]*)");`
`900`	`904`	`reg::Iterator it(txtStr,regExp);`
`901`	`905`	`reg::Iterator end;`
`902`	`906`
`903`		`- //printf("linkifyText scope=%s fileScope=%s strtxt=%s strlen=%d external=%d\n",`
	`907`	`+ //printf("linkifyText scope=%s fileScope=%s strtxt=%s strlen=%zu external=%d\n",`
`904`	`908`	`// scope ? qPrint(scope->name()):"<none>",`
`905`	`909`	`// fileScope ? qPrint(fileScope->name()) : "<none>",`
`906`	`910`	`// qPrint(txtStr),strLen,external);`
`@@ -915,8 +919,8 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`915`	`919`	`floatingIndex+=newIndex-skipIndex+matchLen;`
`916`	`920`	`if (newIndex>0 && txtStr.at(newIndex-1)=='0') // ignore hex numbers (match x00 in 0x00)`
`917`	`921`	`{`
`918`		`- std::string part = txtStr.substr(skipIndex,newIndex+matchLen-skipIndex);`
`919`		`- out.writeString(part.c_str(),keepSpaces);`
	`922`	`+ std::string_view part = txtStr.substr(skipIndex,newIndex+matchLen-skipIndex);`
	`923`	`+ out.writeString(part,keepSpaces);`
`920`	`924`	`skipIndex=index=newIndex+matchLen;`
`921`	`925`	`continue;`
`922`	`926`	`}`
`@@ -932,7 +936,7 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`932`	`936`	`//printf("floatingIndex=%d strlen=%d autoBreak=%d\n",floatingIndex,strLen,autoBreak);`
`933`	`937`	`if (strLen>35 && floatingIndex>30 && autoBreak) // try to insert a split point`
`934`	`938`	`{`
`935`		`- std::string splitText = txtStr.substr(skipIndex,newIndex-skipIndex);`
	`939`	`+ std::string_view splitText = txtStr.substr(skipIndex,newIndex-skipIndex);`
`936`	`940`	`size_t splitLength = splitText.length();`
`937`	`941`	`size_t offset=1;`
`938`	`942`	`size_t i = splitText.find(',');`
`@@ -942,26 +946,26 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`942`	`946`	`//printf("splitText=[%s] len=%d i=%d offset=%d\n",qPrint(splitText),splitLength,i,offset);`
`943`	`947`	`if (i!=std::string::npos) // add a link-break at i in case of Html output`
`944`	`948`	`{`
`945`		`- std::string part1 = splitText.substr(0,i+offset);`
`946`		`- out.writeString(part1.c_str(),keepSpaces);`
	`949`	`+ std::string_view part1 = splitText.substr(0,i+offset);`
	`950`	`+ out.writeString(part1,keepSpaces);`
`947`	`951`	`out.writeBreak(indentLevel==0 ? 0 : indentLevel+1);`
`948`		`- std::string part2 = splitText.substr(i+offset);`
`949`		`- out.writeString(part2.c_str(),keepSpaces);`
	`952`	`+ std::string_view part2 = splitText.substr(i+offset);`
	`953`	`+ out.writeString(part2,keepSpaces);`
`950`	`954`	`floatingIndex=splitLength-i-offset+matchLen;`
`951`	`955`	`}`
`952`	`956`	`else`
`953`	`957`	`{`
`954`		`- out.writeString(splitText.c_str(),keepSpaces);`
	`958`	`+ out.writeString(splitText,keepSpaces);`
`955`	`959`	`}`
`956`	`960`	`}`
`957`	`961`	`else`
`958`	`962`	`{`
`959`	`963`	`//ol.docify(txtStr.mid(skipIndex,newIndex-skipIndex));`
`960`		`- std::string part = txtStr.substr(skipIndex,newIndex-skipIndex);`
`961`		`- out.writeString(part.c_str(),keepSpaces);`
	`964`	`+ std::string_view part = txtStr.substr(skipIndex,newIndex-skipIndex);`
	`965`	`+ out.writeString(part,keepSpaces);`
`962`	`966`	`}`
`963`	`967`	`// get word from string`
`964`		`- std::string word=txtStr.substr(newIndex,matchLen);`
	`968`	`+ std::string_view word=txtStr.substr(newIndex,matchLen);`
`965`	`969`	`QCString matchWord = substitute(substitute(QCString(word),"\\","::"),".","::");`
`966`	`970`	`//printf("linkifyText word=%s matchWord=%s scope=%s\n",`
`967`	`971`	`// qPrint(word),qPrint(matchWord),scope ? qPrint(scope->name()) : "<none>");`
`@@ -977,15 +981,15 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`977`	`981`	`const MemberDef *typeDef = resolver.getTypedef();`
`978`	`982`	`if (typeDef) // First look at typedef then class, see bug 584184.`
`979`	`983`	`{`
`980`		`- //printf("Found typedef %s\n",qPrint(typeDef->name()));`
`981`	`984`	`if (external ? typeDef->isLinkable() : typeDef->isLinkableInProject())`
`982`	`985`	`{`
`983`	`986`	`if (typeDef->getOuterScope()!=self)`
`984`	`987`	`{`
	`988`	`+ //printf("Found typedef %s word='%s'\n",qPrint(typeDef->name()),qPrint(word));`
`985`	`989`	`out.writeLink(typeDef->getReference(),`
`986`	`990`	`typeDef->getOutputFileBase(),`
`987`	`991`	`typeDef->anchor(),`
`988`		`- word.c_str());`
	`992`	`+ word);`
`989`	`993`	`found=TRUE;`
`990`	`994`	`}`
`991`	`995`	`}`
`@@ -995,14 +999,14 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`995`	`999`	`{`
`996`	`1000`	`if (self==nullptr \|\| cd_->qualifiedName()!=self->qualifiedName())`
`997`	`1001`	`{`
`998`		`- out.writeLink(cd_->getReference(),cd_->getOutputFileBase(),cd_->anchor(),word.c_str());`
	`1002`	`+ //printf("Found compound %s word='%s'\n",qPrint(cd->name()),qPrint(word));`
	`1003`	`+ out.writeLink(cd_->getReference(),cd_->getOutputFileBase(),cd_->anchor(),word);`
`999`	`1004`	`found=TRUE;`
`1000`	`1005`	`}`
`1001`	`1006`	`}`
`1002`	`1007`	`};`
`1003`	`1008`	`if (!found && (cd \|\| (cd=getClass(matchWord))))`
`1004`	`1009`	`{`
`1005`		`- //printf("Found class %s\n",qPrint(cd->name()));`
`1006`	`1010`	`writeCompoundName(cd);`
`1007`	`1011`	`}`
`1008`	`1012`	`else if ((cd=getClass(matchWord+"-p"))) // search for Obj-C protocols as well`
`@@ -1035,7 +1039,7 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`1035`	`1039`	`}`
`1036`	`1040`
`1037`	`1041`	`//printf("ScopeName=%s\n",qPrint(scopeName));`
`1038`		`- //if (!found) printf("Trying to link %s in %s\n",qPrint(word),qPrint(scopeName));`
	`1042`	`+ //if (!found) printf("Trying to link '%s' in '%s'\n",qPrint(word),qPrint(scopeName));`
`1039`	`1043`	`if (!found)`
`1040`	`1044`	`{`
`1041`	`1045`	`GetDefInput input(scopeName,matchWord,QCString());`
`@@ -1060,9 +1064,9 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`1060`	`1064`	`)`
`1061`	`1065`	`)`
`1062`	`1066`	`{`
	`1067`	`+ //printf("found symbol %s word='%s'\n",qPrint(result.md->name()),qPrint(word));`
`1063`	`1068`	`out.writeLink(result.md->getReference(),result.md->getOutputFileBase(),`
`1064`		`- result.md->anchor(),word.c_str());`
`1065`		`- //printf("found symbol %s\n",qPrint(matchWord));`
	`1069`	`+ result.md->anchor(),word);`
`1066`	`1070`	`found=TRUE;`
`1067`	`1071`	`}`
`1068`	`1072`	`}`
`@@ -1072,16 +1076,16 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,`
`1072`	`1076`
`1073`	`1077`	`if (!found) // add word to the result`
`1074`	`1078`	`{`
`1075`		`- out.writeString(word.c_str(),keepSpaces);`
	`1079`	`+ out.writeString(word,keepSpaces);`
`1076`	`1080`	`}`
`1077`	`1081`	`// set next start point in the string`
`1078`	`1082`	`//printf("index=%d/%d\n",index,txtStr.length());`
`1079`	`1083`	`skipIndex=index=newIndex+matchLen;`
`1080`	`1084`	`}`
`1081`	`1085`	`// add last part of the string to the result.`
`1082`	`1086`	`//ol.docify(txtStr.right(txtStr.length()-skipIndex));`
`1083`		`- std::string lastPart = txtStr.substr(skipIndex);`
`1084`		`- out.writeString(lastPart.c_str(),keepSpaces);`
	`1087`	`+ std::string_view lastPart = txtStr.substr(skipIndex);`
	`1088`	`+ out.writeString(lastPart,keepSpaces);`
`1085`	`1089`	`}`
`1086`	`1090`
`1087`	`1091`	`void writeMarkerList(OutputList &ol,const std::string &markerText,size_t numMarkers,`
Original file line number	Diff line number	Diff line change
`@@ -212,16 +212,16 @@ class TextGeneratorXMLImpl : public TextGeneratorIntf`
`212`	`212`	`{`
`213`	`213`	`public:`
`214`	`214`	`TextGeneratorXMLImpl(TextStream &t): m_t(t) {}`
`215`		`- void writeString(const QCString &s,bool /keepSpaces/) const override`
	`215`	`+ void writeString(std::string_view s,bool /keepSpaces/) const override`
`216`	`216`	`{`
`217`		`- writeXMLString(m_t,s);`
	`217`	`+ writeXMLString(m_t,QCString(s));`
`218`	`218`	`}`
`219`	`219`	`void writeBreak(int) const override {}`
`220`	`220`	`void writeLink(const QCString &extRef,const QCString &file,`
`221`		`- const QCString &anchor,const QCString &text`
	`221`	`+ const QCString &anchor,std::string_view text`
`222`	`222`	`) const override`
`223`	`223`	`{`
`224`		`- writeXMLLink(m_t,extRef,file,anchor,text,QCString());`
	`224`	`+ writeXMLLink(m_t,extRef,file,anchor,QCString(text),QCString());`
`225`	`225`	`}`
`226`	`226`	`private:`
`227`	`227`	`TextStream &m_t;`