track a separate "tool" attribute of defects

It can be propagated by csdiff's native JSON format and statically
assigned or guessed for the other formats.

Closes: #49

src/csparser.cc

@@ -612,6 +612,7 @@ bool CovParser::Private::parseNext(Defect *def)
     this->keDigger.initVerbosity(def);
     this->annotHdl.handleDef(def);
     this->digger.inferLangFromChecker(def);
+    this->digger.inferToolFromChecker(def);
 
     // all OK
     return true;

src/defect.hh

@@ -94,6 +94,7 @@ struct Defect {
     int                 defectId    = 0;    ///< used only by the JSON format
     std::string         function;           ///< used only by the JSON format
     std::string         language;           ///< used only by the JSON format
+    std::string         tool;               ///< used only by the JSON format
 
     Defect() { }
 

src/gcc-parser.cc

@@ -678,7 +678,8 @@ void GccPostProcessor::apply(Defect *pDef) const
     d->polishGccAnal(pDef);
     d->polishClangAnal(pDef);
 
-    d->digger.inferLangFromChecker(pDef);
+    d->digger.inferLangFromChecker(pDef, /* onlyIfMissing */ false);
+    d->digger.inferToolFromChecker(pDef, /* onlyIfMissing */ false);
 }
 
 struct GccParser::Private {

src/json-parser.cc

@@ -89,6 +89,8 @@ class SarifTreeDecoder: public AbstractTreeDecoder {
 
         typedef std::map<std::string, int>  TCweMap;
         TCweMap                     cweMap;
+
+        ImpliedAttrDigger           digger;
 };
 
 struct JsonParser::Private {
@@ -231,6 +233,7 @@ SimpleTreeDecoder::SimpleTreeDecoder(InStream &input):
         "imp",
         "key_event_idx",
         "language",
+        "tool",
     };
 
     // known per-event subnodes
@@ -312,6 +315,7 @@ bool SimpleTreeDecoder::readNode(
     def->imp      = valueOf<int>        (defNode, "imp"      , 0);
     def->function = valueOf<std::string>(defNode, "function", "");
     def->language = valueOf<std::string>(defNode, "language", "");
+    def->tool     = valueOf<std::string>(defNode, "tool",     "");
 
     if (defNode.not_found() == defNode.find("key_event_idx")) {
         // key event not specified, try to guess it
@@ -349,6 +353,9 @@ bool CovTreeDecoder::readNode(
     def->function = valueOf<std::string>(defNode, "functionDisplayName", "");
     def->language = valueOf<std::string>(defNode, "code-language", "");
 
+    // out of the supported tools, only Coverity produces this data format
+    def->tool = "coverity";
+
     // read CWE if available
     const pt::ptree *checkerProps;
     if (findChildOf(&checkerProps, defNode, "checkerProperties"))
@@ -626,5 +633,8 @@ bool SarifTreeDecoder::readNode(
     if (findChildOf(&relatedLocs, defNode, "relatedLocations"))
         sarifReadComments(def, *relatedLocs);
 
+    this->digger.inferLangFromChecker(def);
+    this->digger.inferToolFromChecker(def);
+
     return true;
 }

src/json-writer.cc

@@ -111,6 +111,8 @@ void SimpleTreeEncoder::appendDef(const Defect &def)
         defNode.put<string>("function", def.function);
     if (!def.language.empty())
         defNode.put<string>("language", def.language);
+    if (!def.tool.empty())
+        defNode.put<string>("tool", def.tool);
 
     defNode.put<int>("key_event_idx", def.keyEventIdx);
     defNode.put_child("events", evtList);

src/parser-common.cc

@@ -19,6 +19,10 @@
 
 #include "parser-common.hh"
 
+#include "regex.hh"
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/replace.hpp>
 #include <boost/lexical_cast.hpp>
 
 int parse_int(const std::string &str, const int fallback)
@@ -34,6 +38,8 @@ int parse_int(const std::string &str, const int fallback)
 struct ImpliedAttrDigger::Private {
     typedef std::map<std::string, std::string>      TMap;
     TMap langByChecker;
+
+    const RE reToolWarning = RE("^([A-Z_]+)_WARNING$");
 };
 
 ImpliedAttrDigger::ImpliedAttrDigger():
@@ -70,3 +76,30 @@ void ImpliedAttrDigger::inferLangFromChecker(
     // found --> assign from map
     pDef->language = it->second;
 }
+
+void ImpliedAttrDigger::inferToolFromChecker(
+        Defect         *pDef,
+        const bool      onlyIfMissing)
+    const
+{
+    if (onlyIfMissing && !pDef->tool.empty())
+        // tool already assigned
+        return;
+
+    boost::smatch sm;
+    if (boost::regex_match(pDef->checker, sm, d->reToolWarning)) {
+        // extract tool="gcc-analyzer" out of checker="GCC_ANALYZER_WARNING"
+        std::string tool = sm[/* tool */ 1];
+        boost::algorithm::to_lower(tool);
+        boost::algorithm::replace_all(tool, "_", "-");
+
+        if (tool == "compiler")
+            // we use COMPILER_WARNING for "gcc" due to historical reasons
+            tool = "gcc";
+
+        pDef->tool = tool;
+    }
+    else
+        // no tool matched --> assume coverity
+        pDef->tool = "coverity";
+}

src/parser-common.hh

@@ -41,6 +41,7 @@ class ImpliedAttrDigger {
         ~ImpliedAttrDigger();
 
         void inferLangFromChecker(Defect *, bool onlyIfMissing = true) const;
+        void inferToolFromChecker(Defect *, bool onlyIfMissing = true) const;
 
     private:
         struct Private;

src/xml-parser.cc

@@ -114,6 +114,9 @@ void ValgrindTreeDecoder::readRoot(
     // valgrind reports will be at the same level in the XML tree
     *pDefList = root;
 
+    // only valgrind produces this data format
+    this->defPrototype.tool = "valgrind";
+
     const int pid = valueOf<int>(*root, "pid", 0);
     if (!pid)
         // insufficient data