Merge branch 'master' of github.com:doxygen/doxygen

doxygen · doxygen · commit 1f0746c17fb0 · 2025-02-27T20:58:52.000+01:00
diff --git a/src/clangparser.cpp b/src/clangparser.cpp
@@ -706,7 +706,7 @@ void ClangTUParser::linkMacro(OutputCodeList &ol,const FileDef *fd,
 void ClangTUParser::linkIdentifier(OutputCodeList &ol,const FileDef *fd,
     uint32_t &line,uint32_t &column,const char *text,int tokenIndex)
 {
-  AUTO_TRACE("line={} colum={} text={}",line,column,text);
+  AUTO_TRACE("line={} column={} text={}",line,column,text);
   CXCursor c = p->cursors[tokenIndex];
   CXCursorKind cKind = clang_getCursorKind(c);
   AUTO_TRACE_ADD("cursor kind={}",(int)cKind);
diff --git a/src/commentcnv.l b/src/commentcnv.l
@@ -1746,7 +1746,7 @@ static bool readIncludeFile(yyscan_t yyscanner,const QCString &inc,const QCStrin
       int count = incText.contains(blockId.data());
       if (count!=2)
       {
-        warn_doc_error(yyextra->fileName,yyextra->lineNr,"block marked with [{}] for \\snippet{{doc}} should appear twice in file {}, found it {:d} times, skipping",
+        warn_doc_error(yyextra->fileName,yyextra->lineNr,"block marked with {} for \\snippet{{doc}} should appear twice in file {}, found it {:d} times, skipping",
             blockId,absFileName,count);
         return false;
       }
diff --git a/src/commentscan.l b/src/commentscan.l
@@ -572,6 +572,7 @@ static inline const char *getLexerFILE() {return __FILE__;}
 CMD       ("\\"|"@")
 PRE       ("pre"|"PRE")
 TABLE     ("table"|"TABLE")
+TABLEDEL  ("table"|"tr"|"th"|"td"|"TABLE"|"TR"|"TH"|"TD")
 P         [pP]
 UL        ("ul"|"UL")
 OL        ("ol"|"OL")
@@ -1213,6 +1214,17 @@ STopt  [^\n@\\]*
                                           addOutput(yyscanner,yytext);
                                           if (*yytext == '\n') yyextra->lineNr++;
                                         }
+<Comment>"<"[/]?{TABLEDEL}">"           { // In case in xrefitem type some special handling is required
+                                          if (yyextra->inContext==OutputXRef)
+                                          {
+                                            setOutput(yyscanner,OutputDoc);
+                                            addOutput(yyscanner,yytext);
+                                          }
+                                          else
+                                          {
+                                            REJECT;
+                                          }
+                                        }
 <Comment>.                              { // catch-all for anything else
                                           addOutput(yyscanner,*yytext);
                                         }
diff --git a/src/defgen.cpp b/src/defgen.cpp
@@ -114,23 +114,8 @@ static void generateDEFForMember(const MemberDef *md,
     << md->getOutputFileBase() << "_1" << md->anchor()
     << "';\n";
 
-  t << memPrefix << "virt = ";
-  switch (md->virtualness())
-  {
-    case Specifier::Normal:  t << "normal;\n"; break;
-    case Specifier::Virtual: t << "virtual;\n"; break;
-    case Specifier::Pure:    t << "pure-virtual;\n"; break;
-    default: ASSERT(0);
-  }
-
-  t << memPrefix << "prot = ";
-  switch(md->protection())
-  {
-    case Protection::Public:    t << "public;\n"; break;
-    case Protection::Protected: t << "protected;\n"; break;
-    case Protection::Private:   t << "private;\n"; break;
-    case Protection::Package:   t << "package;\n"; break;
-  }
+  t << memPrefix << "virt = " << to_string_lower(md->virtualness()) << ";\n";
+  t << memPrefix << "prot = " << to_string_lower(md->protection()) << ";\n";
 
   if (md->memberType()!=MemberType::Define &&
       md->memberType()!=MemberType::Enumeration
@@ -341,47 +326,19 @@ static void generateDEFForClass(const ClassDef *cd,TextStream &t)
   for (const auto &bcd : cd->baseClasses())
   {
     t << "  cp-ref     = {\n" << "    ref-type = base;\n";
-    t << "    ref-id   = '"
-      << bcd.classDef->getOutputFileBase() << "';\n";
-    t << "    ref-prot = ";
-    switch (bcd.prot)
-    {
-      case Protection::Public:    t << "public;\n"; break;
-      case Protection::Package: // package scope is not possible
-      case Protection::Protected: t << "protected;\n"; break;
-      case Protection::Private:   t << "private;\n"; break;
-    }
-    t << "    ref-virt = ";
-    switch(bcd.virt)
-    {
-      case Specifier::Normal:  t << "non-virtual;";  break;
-      case Specifier::Virtual: t << "virtual;";      break;
-      case Specifier::Pure:    t << "pure-virtual;"; break;
-    }
-    t << "\n  };\n";
+    t << "    ref-id   = '" << bcd.classDef->getOutputFileBase() << "';\n";
+    t << "    ref-prot = " << to_string_lower_class(bcd.prot) << ";\n";
+    t << "    ref-virt = " << to_string_lower(bcd.virt) << ";\n";
+    t << "  };\n";
   }
 
   for (const auto &bcd : cd->subClasses())
   {
     t << "  cp-ref     = {\n" << "    ref-type = derived;\n";
-    t << "    ref-id   = '"
-      << bcd.classDef->getOutputFileBase() << "';\n";
-    t << "    ref-prot = ";
-    switch (bcd.prot)
-    {
-      case Protection::Public:    t << "public;\n"; break;
-      case Protection::Package: // packet scope is not possible!
-      case Protection::Protected: t << "protected;\n"; break;
-      case Protection::Private:   t << "private;\n"; break;
-    }
-    t << "    ref-virt = ";
-    switch (bcd.virt)
-    {
-      case Specifier::Normal:  t << "non-virtual;";  break;
-      case Specifier::Virtual: t << "virtual;";      break;
-      case Specifier::Pure:    t << "pure-virtual;"; break;
-    }
-    t << "\n  };\n";
+    t << "    ref-id   = '" << bcd.classDef->getOutputFileBase() << "';\n";
+    t << "    ref-prot = " << to_string_lower_class(bcd.prot) << ";\n";
+    t << "    ref-virt = " << to_string_lower(bcd.virt) << ";\n";
+    t << "  };\n";
   }
 
   size_t numMembers = 0;
diff --git a/src/htmldocvisitor.cpp b/src/htmldocvisitor.cpp
@@ -1695,7 +1695,7 @@ void HtmlDocVisitor::operator()(const DocImage &img)
     {
       src = correctURL(url,img.relPath());
     }
-    if (typeSVG && !inlineImage)
+    if (typeSVG && !inlineImage && !src.startsWith("http://") && !src.startsWith("https://"))
     {
       m_t << "<object type=\"image/svg+xml\" data=\"" << convertToHtml(src)
         << "\"" << sizeAttribs << attrs;
diff --git a/src/memberdef.cpp b/src/memberdef.cpp
@@ -3367,8 +3367,12 @@ void MemberDefImpl::_writeGroupInclude(OutputList &ol,bool inGroup) const
   bool showGroupedMembInc = Config_getBool(SHOW_GROUPED_MEMB_INC);
   const FileDef *fd = getFileDef();
   QCString nm;
-  if (fd) nm = getFileDef()->docName();
-  if (inGroup && fd && showGroupedMembInc && !nm.isEmpty())
+  if (inGroup && fd && showGroupedMembInc)
+  {
+    nm = fd->absFilePath();
+    nm = stripFromIncludePath(nm);
+  }
+  if (!nm.isEmpty())
   {
     ol.startParagraph();
     ol.startTypewriter();
@@ -3533,6 +3537,7 @@ void MemberDefImpl::writeDocumentation(const MemberList *ml,
   ldef.stripPrefix("constexpr ");
   ldef.stripPrefix("consteval ");
   ldef.stripPrefix("constinit ");
+  ldef.stripPrefix("static ");
 
   //----------------------------------------
 
diff --git a/src/message.cpp b/src/message.cpp
@@ -17,6 +17,7 @@
 #include <cstdlib>
 #include <mutex>
 #include <atomic>
+#include <unordered_set>
 
 #include "config.h"
 #include "debug.h"
@@ -25,6 +26,7 @@
 #include "doxygen.h"
 #include "fileinfo.h"
 #include "dir.h"
+#include "md5.h"
 
 // globals
 static QCString        g_warnFormat;
@@ -37,9 +39,20 @@ static QCString        g_warnlogFile;
 static bool            g_warnlogTemp = false;
 static std::atomic_bool g_warnStat = false;
 static std::mutex      g_mutex;
+static std::unordered_set<std::string> g_warnHash;
 
 //-----------------------------------------------------------------------------------------
 
+static bool checkWarnMessage(QCString result)
+{
+  uint8_t md5_sig[16];
+  char sigStr[33];
+  MD5Buffer(result.data(),result.length(),md5_sig);
+  MD5SigToString(md5_sig,sigStr);
+
+  return g_warnHash.insert(sigStr).second;
+}
+
 static void format_warn(const QCString &file,int line,const QCString &text)
 {
   QCString fileSubst = file.isEmpty() ? "<unknown>" : file;
@@ -70,7 +83,7 @@ static void format_warn(const QCString &file,int line,const QCString &text)
   {
     std::unique_lock<std::mutex> lock(g_mutex);
     // print resulting message
-    fwrite(msgText.data(),1,msgText.length(),g_warnFile);
+    if (checkWarnMessage(msgText)) fwrite(msgText.data(),1,msgText.length(),g_warnFile);
   }
   if (g_warnBehavior == WARN_AS_ERROR_t::YES)
   {
@@ -150,15 +163,21 @@ void warn_(WarningType type, const QCString &file, int line, fmt::string_view fm
 
 void warn_uncond_(fmt::string_view fmt, fmt::format_args args)
 {
-  fmt::print(g_warnFile,"{}{}",g_warningStr,vformat(fmt,args));
+  {
+    std::unique_lock<std::mutex> lock(g_mutex);
+    if (checkWarnMessage(g_errorStr+fmt::vformat(fmt,args))) fmt::print(g_warnFile,"{}{}",g_warningStr,vformat(fmt,args));
+  }
   handle_warn_as_error();
 }
 
 //-----------------------------------------------------------------------------------------
 
 void err_(fmt::string_view fmt, fmt::format_args args)
 {
-  fmt::print(g_warnFile,"{}{}",g_errorStr,fmt::vformat(fmt,args));
+  {
+    std::unique_lock<std::mutex> lock(g_mutex);
+    if (checkWarnMessage(g_errorStr+fmt::vformat(fmt,args))) fmt::print(g_warnFile,"{}{}",g_errorStr,fmt::vformat(fmt,args));
+  }
   handle_warn_as_error();
 }
 
@@ -175,7 +194,7 @@ void term_(fmt::string_view fmt, fmt::format_args args)
 {
   {
     std::unique_lock<std::mutex> lock(g_mutex);
-    fmt::print(g_warnFile, "{}{}", g_errorStr, fmt::vformat(fmt,args));
+    if (checkWarnMessage(g_errorStr+fmt::vformat(fmt,args))) fmt::print(g_warnFile, "{}{}", g_errorStr, fmt::vformat(fmt,args));
     if (g_warnFile != stderr)
     {
       size_t l = strlen(g_errorStr);
diff --git a/src/message.h b/src/message.h
@@ -156,108 +156,47 @@ template<> struct fmt::formatter<QCString> : formatter<std::string>
 template<> struct fmt::formatter<Protection> : formatter<std::string>
 {
   auto format(Protection prot, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (prot)
-    {
-      case Protection::Public:    result="Public";     break;
-      case Protection::Protected: result="Protected";  break;
-      case Protection::Private:   result="Private";    break;
-      case Protection::Package:   result="Package";    break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(prot), ctx);
   }
 };
 
 //! adds support for formatting Specifier
 template<> struct fmt::formatter<Specifier> : formatter<std::string>
 {
   auto format(Specifier spec, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (spec)
-    {
-      case Specifier::Normal:   result="Normal";  break;
-      case Specifier::Virtual:  result="Virtual"; break;
-      case Specifier::Pure:     result="Pure";    break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(spec), ctx);
   }
 };
 
 //! adds support for formatting MethodTypes
 template<> struct fmt::formatter<MethodTypes> : formatter<std::string>
 {
   auto format(MethodTypes mtype, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (mtype)
-    {
-      case MethodTypes::Method:   result="Method";   break;
-      case MethodTypes::Signal:   result="Signal";   break;
-      case MethodTypes::Slot:     result="Slot";     break;
-      case MethodTypes::DCOP:     result="DCOP";     break;
-      case MethodTypes::Property: result="Property"; break;
-      case MethodTypes::Event:    result="Event";    break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(mtype), ctx);
   }
 };
 
 //! adds support for formatting RelatesType
 template<> struct fmt::formatter<RelatesType> : formatter<std::string>
 {
   auto format(RelatesType type, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (type)
-    {
-      case RelatesType::Simple:    result="Simple";    break;
-      case RelatesType::Duplicate: result="Duplicate"; break;
-      case RelatesType::MemberOf:  result="MemberOf";  break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(type), ctx);
   }
 };
 
 //! adds support for formatting RelationShip
 template<> struct fmt::formatter<Relationship> : formatter<std::string>
 {
   auto format(Relationship relation, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (relation)
-    {
-      case Relationship::Member:  result="Member";  break;
-      case Relationship::Related: result="Related"; break;
-      case Relationship::Foreign: result="Foreign"; break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(relation), ctx);
   }
 };
 
 //! adds support for formatting SrcLangExt
 template<> struct fmt::formatter<SrcLangExt> : formatter<std::string>
 {
   auto format(SrcLangExt lang, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (lang)
-    {
-      case SrcLangExt::Unknown:  result="Unknown";     break;
-      case SrcLangExt::IDL:      result="IDL";         break;
-      case SrcLangExt::Java:     result="Java";        break;
-      case SrcLangExt::CSharp:   result="C#";          break;
-      case SrcLangExt::D:        result="D";           break;
-      case SrcLangExt::PHP:      result="PHP";         break;
-      case SrcLangExt::ObjC:     result="Objective-C"; break;
-      case SrcLangExt::Cpp:      result="C++";         break;
-      case SrcLangExt::JS:       result="Javascript";  break;
-      case SrcLangExt::Python:   result="Python";      break;
-      case SrcLangExt::Fortran:  result="Fortran";     break;
-      case SrcLangExt::VHDL:     result="VHDL";        break;
-      case SrcLangExt::XML:      result="XML";         break;
-      //case SrcLangExt::Tcl:    result="Tcl";         break;
-      case SrcLangExt::Markdown: result="Markdown";    break;
-      case SrcLangExt::SQL:      result="SQL";         break;
-      case SrcLangExt::Slice:    result="Slice";       break;
-      case SrcLangExt::Lex:      result="Lex";         break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(lang), ctx);
   }
 };
 
diff --git a/src/perlmodgen.cpp b/src/perlmodgen.cpp
@@ -1386,25 +1386,12 @@ static void addPerlModDocBlock(PerlModOutput &output,
 
 static const char *getProtectionName(Protection prot)
 {
-  switch (prot)
-  {
-    case Protection::Public:    return "public";
-    case Protection::Protected: return "protected";
-    case Protection::Private:   return "private";
-    case Protection::Package:   return "package";
-  }
-  return nullptr;
+  return to_string_lower(prot);
 }
 
 static const char *getVirtualnessName(Specifier virt)
 {
-  switch(virt)
-  {
-    case Specifier::Normal:  return "non_virtual";
-    case Specifier::Virtual: return "virtual";
-    case Specifier::Pure:    return "pure_virtual";
-  }
-  return nullptr;
+  return to_string_lower(virt);
 }
 
 static QCString pathDoxyfile;
diff --git a/src/pyscanner.l b/src/pyscanner.l
@@ -1771,13 +1771,19 @@ static void initEntry(yyscan_t yyscanner)
   yyextra->current->lang       = SrcLangExt::Python;
   yyextra->current->type.clear();
   yyextra->current->name.clear();
+  yyextra->current->initializer.clear();
   yyextra->commentScanner.initGroupInfo(yyextra->current.get());
   yyextra->isStatic = FALSE;
 }
 
 static void newEntry(yyscan_t yyscanner)
 {
   struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  if (yyextra->current->name.isEmpty())
+  {
+    initEntry(yyscanner);
+    return;
+  }
   bool found = false;
   if (yyextra->checkDupEntry)
   {
diff --git a/src/types.h b/src/types.h
diff --git a/src/util.cpp b/src/util.cpp
diff --git a/src/xmlgen.cpp b/src/xmlgen.cpp

Original file line number	Diff line number	Diff line change
`@@ -706,7 +706,7 @@ void ClangTUParser::linkMacro(OutputCodeList &ol,const FileDef *fd,`
`706`	`706`	`void ClangTUParser::linkIdentifier(OutputCodeList &ol,const FileDef *fd,`
`707`	`707`	`uint32_t &line,uint32_t &column,const char *text,int tokenIndex)`
`708`	`708`	`{`
`709`		`- AUTO_TRACE("line={} colum={} text={}",line,column,text);`
	`709`	`+ AUTO_TRACE("line={} column={} text={}",line,column,text);`
`710`	`710`	`CXCursor c = p->cursors[tokenIndex];`
`711`	`711`	`CXCursorKind cKind = clang_getCursorKind(c);`
`712`	`712`	`AUTO_TRACE_ADD("cursor kind={}",(int)cKind);`
Original file line number	Diff line number	Diff line change
`@@ -1746,7 +1746,7 @@ static bool readIncludeFile(yyscan_t yyscanner,const QCString &inc,const QCStrin`
`1746`	`1746`	`int count = incText.contains(blockId.data());`
`1747`	`1747`	`if (count!=2)`
`1748`	`1748`	`{`
`1749`		`- warn_doc_error(yyextra->fileName,yyextra->lineNr,"block marked with [{}] for \\snippet{{doc}} should appear twice in file {}, found it {:d} times, skipping",`
	`1749`	`+ warn_doc_error(yyextra->fileName,yyextra->lineNr,"block marked with {} for \\snippet{{doc}} should appear twice in file {}, found it {:d} times, skipping",`
`1750`	`1750`	`blockId,absFileName,count);`
`1751`	`1751`	`return false;`
`1752`	`1752`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1695,7 +1695,7 @@ void HtmlDocVisitor::operator()(const DocImage &img)`
`1695`	`1695`	`{`
`1696`	`1696`	`src = correctURL(url,img.relPath());`
`1697`	`1697`	`}`
`1698`		`- if (typeSVG && !inlineImage)`
	`1698`	`+ if (typeSVG && !inlineImage && !src.startsWith("http://") && !src.startsWith("https://"))`
`1699`	`1699`	`{`
`1700`	`1700`	`m_t << "<object type=\"image/svg+xml\" data=\"" << convertToHtml(src)`
`1701`	`1701`	`<< "\"" << sizeAttribs << attrs;`
Original file line number	Diff line number	Diff line change
`@@ -1771,13 +1771,19 @@ static void initEntry(yyscan_t yyscanner)`
`1771`	`1771`	`yyextra->current->lang = SrcLangExt::Python;`
`1772`	`1772`	`yyextra->current->type.clear();`
`1773`	`1773`	`yyextra->current->name.clear();`
	`1774`	`+ yyextra->current->initializer.clear();`
`1774`	`1775`	`yyextra->commentScanner.initGroupInfo(yyextra->current.get());`
`1775`	`1776`	`yyextra->isStatic = FALSE;`
`1776`	`1777`	`}`
`1777`	`1778`
`1778`	`1779`	`static void newEntry(yyscan_t yyscanner)`
`1779`	`1780`	`{`
`1780`	`1781`	`struct yyguts_t yyg = (struct yyguts_t)yyscanner;`
	`1782`	`+ if (yyextra->current->name.isEmpty())`
	`1783`	`+ {`
	`1784`	`+ initEntry(yyscanner);`
	`1785`	`+ return;`
	`1786`	`+ }`
`1781`	`1787`	`bool found = false;`
`1782`	`1788`	`if (yyextra->checkDupEntry)`
`1783`	`1789`	`{`