fix #13362: Misra report on command line

cli/cmdlineparser.cpp

@@ -1227,6 +1227,29 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                 mSettings.reportProgress = tmp;
             }
 
+            else if (std::strncmp(argv[i], "--report-type=", 14) == 0) {
+                const std::string typeStr = argv[i] + 14;
+                if (typeStr == "normal") {
+                    mSettings.reportType = ReportType::normal;
+                } else if (typeStr == "autosar") {
+                    mSettings.reportType = ReportType::autosar;
+                } else if (typeStr == "certC") {
+                    mSettings.reportType = ReportType::certC;
+                } else if (typeStr == "certCpp") {
+                    mSettings.reportType = ReportType::certCpp;
+                } else if (typeStr == "misraC") {
+                    mSettings.reportType = ReportType::misraC;
+                } else if (typeStr == "misraCpp2008") {
+                    mSettings.reportType = ReportType::misraCpp2008;
+                } else if (typeStr == "misraCpp2023") {
+                    mSettings.reportType = ReportType::misraCpp2023;
+                } else {
+                    mLogger.printError("Unknown report type \'" + typeStr + "\'");
+                    return Result::Fail;
+                }
+                mSettings.guidelineMapping = createGuidelineMapping(mSettings.reportType);
+            }
+
             // Rule given at command line
             else if (std::strncmp(argv[i], "--rule=", 7) == 0) {
 #ifdef HAVE_RULES
@@ -1824,6 +1847,15 @@ void CmdLineParser::printHelp() const
         "                         currently only possible to apply the base paths to\n"
         "                         files that are on a lower level in the directory tree.\n"
         "    --report-progress    Report progress messages while checking a file (single job only).\n"
+        "    --report-type=<type> Add guideline and classification fields for specified coding standard.\n"
+        "                         The available report types are:\n"
+        "                          * normal           Default, only show cppcheck error ID and severity)\n"
+        "                          * autosar          Autosar\n"
+        "                          * certC            Cert C\n"
+        "                          * certCpp          Cert Cpp\n"
+        "                          * misraC           Misra C\n"
+        "                          * misraCpp2008     Misra C++ 2008\n"
+        "                          * misraCpp2023     Misra C++ 2023\n"
         "    --rule=<rule>        Match regular expression.\n"
         "    --rule-file=<file>   Use given rule file. For more information, see:\n"
         "                         http://sourceforge.net/projects/cppcheck/files/Articles/\n"

cli/cppcheckexecutor.cpp

@@ -626,12 +626,17 @@ void StdLogger::reportErr(const ErrorMessage &msg)
     if (!mSettings.emitDuplicates && !mShownErrors.insert(msg.toString(mSettings.verbose)).second)
         return;
 
+    ErrorMessage msgCopy = msg;
+    msgCopy.guideline = getGuideline(msgCopy.id, mSettings.reportType,
+                                     mSettings.guidelineMapping, msgCopy.severity);
+    msgCopy.classification = getClassification(msgCopy.guideline, mSettings.reportType);
+
     if (mSettings.outputFormat == Settings::OutputFormat::sarif)
-        mSarifReport.addFinding(msg);
+        mSarifReport.addFinding(msgCopy);
     else if (mSettings.xml)
-        reportErr(msg.toXML());
+        reportErr(msgCopy.toXML());
     else
-        reportErr(msg.toString(mSettings.verbose, mSettings.templateFormat, mSettings.templateLocation));
+        reportErr(msgCopy.toString(mSettings.verbose, mSettings.templateFormat, mSettings.templateLocation));
 }
 
 /**

gui/common.h

@@ -24,6 +24,8 @@
 #include <QMap>
 #include <QString>
 
+#include "errorlogger.h"
+
 /// @addtogroup GUI
 /// @{
 
@@ -52,7 +54,6 @@
 
 // Report type
 #define SETTINGS_REPORT_TYPE            "Report type"
-enum class ReportType : std::uint8_t { normal=0, autosar=1, certC=2, certCpp=3, misraC=4, misraCpp2008=5, misraCpp2023=6 };
 
 // Show * states
 #define SETTINGS_SHOW_STYLE             "Show style"

gui/resultstree.cpp

@@ -98,110 +98,15 @@ static constexpr int COLUMN_SINCE_DATE            = 10;
 static constexpr int COLUMN_TAGS                  = 11;
 static constexpr int COLUMN_CWE                   = 12;
 
-static QString getGuideline(ReportType reportType, const QMap<QString,QString>& guidelines, const QString& errorId, Severity severity) {
-    if (reportType == ReportType::autosar) {
-        if (errorId.startsWith("premium-autosar-"))
-            return errorId.mid(16);
-        if (errorId.startsWith("premium-misra-cpp-2008-"))
-            return "M" + errorId.mid(23);
-    }
-    if (reportType == ReportType::certC || reportType == ReportType::certCpp) {
-        if (errorId.startsWith("premium-cert-"))
-            return errorId.mid(13).toUpper();
-    }
-    if (errorId.startsWith("premium-"))
-        return getGuideline(reportType, guidelines, errorId.mid(8), severity);
-    if (reportType == ReportType::misraC && (errorId.startsWith("misra-c20") || errorId.startsWith("misra-c-20")))
-        return errorId.mid(errorId.lastIndexOf("-") + 1);
-    if (reportType == ReportType::misraCpp2008 && errorId.startsWith("misra-cpp-2008-"))
-        return errorId.mid(15);
-    if (reportType == ReportType::misraCpp2023 && errorId.startsWith("misra-cpp-2023-"))
-        return errorId.mid(15);
-    const QString& guideline = guidelines.value(errorId);
-    if (!guideline.isEmpty())
-        return guideline;
-    if (severity == Severity::error || severity == Severity::warning)
-        return guidelines.value("error");
-    return QString();
+static QString getGuideline(ReportType reportType, const std::map<std::string, std::string> &guidelineMapping,
+                            const QString& errorId, Severity severity) {
+    return QString::fromStdString(getGuideline(errorId.toStdString(),
+                                               reportType, guidelineMapping,
+                                               severity));
 }
 
 static QString getClassification(ReportType reportType, const QString& guideline) {
-    if (guideline.isEmpty())
-        return QString();
-    auto getFromInfo = [](const std::vector<checkers::Info>& info, const QString& guideline) -> QString {
-        for (const checkers::Info& i: info) {
-            // cppcheck-suppress useStlAlgorithm
-            if (guideline.compare(i.guideline, Qt::CaseInsensitive) == 0)
-                return i.classification;
-        }
-        return QString();
-    };
-    if (reportType == ReportType::autosar)
-        return getFromInfo(checkers::autosarInfo, guideline);
-    if (reportType == ReportType::certC || reportType == ReportType::certCpp) {
-        if (guideline.endsWith("-CPP"))
-            return getFromInfo(checkers::certCppInfo, guideline);
-        if (guideline.endsWith("-C"))
-            return getFromInfo(checkers::certCInfo, guideline);
-    }
-    else if (reportType == ReportType::misraC) {
-        QStringList list = guideline.split(".");
-        if (list.size() == 2) {
-            bool ok = true;
-            const int a = list[0].toInt(&ok);
-            if (!ok)
-                return QString();
-            const int b = list[1].toInt(&ok);
-            if (!ok)
-                return QString();
-            for (const auto& info: checkers::misraC2012Rules) {
-                // cppcheck-suppress useStlAlgorithm
-                if (info.a == a && info.b == b)
-                    return info.str;
-            }
-        }
-    }
-    else if (reportType == ReportType::misraCpp2008) {
-        QStringList list = guideline.split("-");
-        if (list.size() == 3) {
-            bool ok = true;
-            const int a = list[0].toInt(&ok);
-            if (!ok)
-                return QString();
-            const int b = list[1].toInt(&ok);
-            if (!ok)
-                return QString();
-            const int c = list[2].toInt(&ok);
-            if (!ok)
-                return QString();
-            for (const auto& info: checkers::misraCpp2008Rules) {
-                // cppcheck-suppress useStlAlgorithm
-                if (info.a == a && info.b == b && info.c == c)
-                    return info.classification;
-            }
-        }
-    }
-    else if (reportType == ReportType::misraCpp2023) {
-        QStringList list = guideline.split(".");
-        if (list.size() == 3) {
-            bool ok = true;
-            const int a = list[0].toInt(&ok);
-            if (!ok)
-                return QString();
-            const int b = list[1].toInt(&ok);
-            if (!ok)
-                return QString();
-            const int c = list[2].toInt(&ok);
-            if (!ok)
-                return QString();
-            for (const auto& info: checkers::misraCpp2023Rules) {
-                // cppcheck-suppress useStlAlgorithm
-                if (info.a == a && info.b == b && info.c == c)
-                    return info.classification;
-            }
-        }
-    }
-    return QString();
+    return QString::fromStdString(getClassification(guideline.toStdString(), reportType));
 }
 
 static Severity getSeverityFromClassification(const QString &c) {
@@ -262,26 +167,7 @@ void ResultsTree::keyPressEvent(QKeyEvent *event)
 void ResultsTree::setReportType(ReportType reportType) {
     mReportType = reportType;
 
-    auto readIdMapping = [this](const std::vector<checkers::IdMapping>& idMapping, const char* ext = "") {
-        for (const auto& i: idMapping)
-            for (const QString& cppcheckId: QString(i.cppcheckId).split(","))
-                mGuideline[cppcheckId] = QString(i.guideline) + ext;
-    };
-
-    if (reportType == ReportType::autosar)
-        readIdMapping(checkers::idMappingAutosar);
-    else if (reportType == ReportType::certC)
-        readIdMapping(checkers::idMappingCertC, "-C");
-    else if (reportType == ReportType::certCpp) {
-        readIdMapping(checkers::idMappingCertC, "-C");
-        readIdMapping(checkers::idMappingCertCpp, "-CPP");
-    }
-    else if (reportType == ReportType::misraC)
-        readIdMapping(checkers::idMappingMisraC);
-    else if (reportType == ReportType::misraCpp2008)
-        readIdMapping(checkers::idMappingMisraCpp2008);
-    else if (reportType == ReportType::misraCpp2023)
-        readIdMapping(checkers::idMappingMisraCpp2023);
+    mGuideline = createGuidelineMapping(reportType);
 
     for (int i = 0; i < mModel.rowCount(); ++i) {
         const QStandardItem *fileItem = mModel.item(i, COLUMN_FILE);

gui/resultstree.h

@@ -540,7 +540,7 @@ protected slots:
 
     ReportType mReportType = ReportType::normal;
 
-    QMap<QString,QString> mGuideline;
+    std::map<std::string, std::string> mGuideline;
 };
 /// @}
 #endif // RESULTSTREE_H

gui/resultsview.h

@@ -22,6 +22,7 @@
 
 #include "report.h"
 #include "showtypes.h"
+#include "common.h"
 
 #include <cstdint>
 
@@ -39,7 +40,6 @@ class QPrinter;
 class QSettings;
 class CheckStatistics;
 class QPoint;
-enum class ReportType : std::uint8_t;
 namespace Ui {
     class ResultsView;
 }

gui/test/resultstree/CMakeLists.txt

@@ -6,6 +6,10 @@ qt_wrap_cpp(test-resultstree_SRC
         ${CMAKE_SOURCE_DIR}/gui/threadhandler.h
         ${CMAKE_SOURCE_DIR}/gui/threadresult.h
 )
+if(USE_BUNDLED_TINYXML2)
+    list(APPEND test-resultstree_SRC $<TARGET_OBJECTS:tinyxml2_objs>)
+endif()
+list(APPEND test-resultstree_SRC $<TARGET_OBJECTS:simplecpp_objs> $<TARGET_OBJECTS:cppcheck-core>)
 add_custom_target(build-resultstree-deps SOURCES ${test-resultstree_SRC})
 add_dependencies(gui-build-deps build-resultstree-deps)
 add_executable(test-resultstree
@@ -16,12 +20,23 @@ add_executable(test-resultstree
         ${CMAKE_SOURCE_DIR}/gui/showtypes.cpp
         ${CMAKE_SOURCE_DIR}/gui/report.cpp
         ${CMAKE_SOURCE_DIR}/gui/xmlreportv2.cpp
-        ${CMAKE_SOURCE_DIR}/lib/checkers.cpp
-        ${CMAKE_SOURCE_DIR}/lib/checkersidmapping.cpp
         )
 target_include_directories(test-resultstree PRIVATE ${CMAKE_SOURCE_DIR}/gui ${CMAKE_SOURCE_DIR}/lib)
+target_externals_include_directories(test-resultstree PRIVATE ${CMAKE_SOURCE_DIR}/externals/simplecpp)
+if(USE_BUNDLED_TINYXML2)
+    target_externals_include_directories(test-resultstree PRIVATE ${PROJECT_SOURCE_DIR}/externals/tinyxml2/)
+else()
+    target_include_directories(test-resultstree SYSTEM PRIVATE ${tinyxml2_INCLUDE_DIRS})
+endif()
+if (HAVE_RULES)
+    target_link_libraries(test-resultstree ${PCRE_LIBRARY})
+    target_include_directories(test-resultstree SYSTEM PRIVATE ${PCRE_INCLUDE})
+endif()
 target_compile_definitions(test-resultstree PRIVATE SRCDIR="${CMAKE_CURRENT_SOURCE_DIR}")
 target_link_libraries(test-resultstree ${QT_CORE_LIB} ${QT_GUI_LIB} ${QT_WIDGETS_LIB} ${QT_TEST_LIB})
+if(tinyxml2_FOUND AND NOT USE_BUNDLED_TINYXML2)
+    target_link_libraries(test-resultstree ${tinyxml2_LIBRARIES})
+endif()
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     # Q_UNUSED() in generated code

gui/test/resultstree/testresultstree.cpp

@@ -76,9 +76,6 @@ void ProjectFile::setWarningTags(std::size_t /*unused*/, const QString& /*unused
 bool ProjectFile::write(const QString & /*unused*/) {
     return true;
 }
-std::string severityToString(Severity severity) {
-    return std::to_string((int)severity);
-}
 ApplicationList::ApplicationList(QObject *parent) : QObject(parent) {}
 ApplicationList::~ApplicationList() = default;
 int ApplicationList::getApplicationCount() const {
@@ -122,24 +119,6 @@ void ThreadResult::reportErr(const ErrorMessage & /*unused*/) {
     throw 1;
 }
 
-// Mock LIB...
-bool Path::isHeader(std::string const& /*unused*/) {
-    return false;
-}
-const std::set<std::string> ErrorLogger::mCriticalErrorIds;
-std::string ErrorMessage::FileLocation::getfile(bool /*unused*/) const {
-    return std::string();
-}
-const char* CppCheck::version() {
-    return "1.0";
-}
-std::pair<std::string, std::string> Settings::getNameAndVersion(const std::string& /*unused*/) {
-    throw 1;
-}
-Severity severityFromString(const std::string& severity) {
-    return (Severity)std::stoi(severity);
-}
-
 // Test...
 
 void TestResultsTree::test1() const