extracted Rule from settings.h to rule.h / added Regex::engine() / removed unnecessary Rule::engine (#8580)

Author: firewave

Makefile

@@ -57,6 +57,7 @@
 
 #ifdef HAVE_RULES
 #include "regex.h"
+#include "rule.h"
 
 // xml is used for rules
 #include "xml.h"
@@ -1304,7 +1305,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
         // Rule given at command line
         else if (std::strncmp(argv[i], "--rule=", 7) == 0) {
 #ifdef HAVE_RULES
-            Settings::Rule rule;
+            Rule rule;
             rule.pattern = 7 + argv[i];
 
             if (rule.pattern.empty()) {
@@ -1340,7 +1341,8 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                 if (node && strcmp(node->Value(), "rules") == 0)
                     node = node->FirstChildElement("rule");
                 for (; node && strcmp(node->Value(), "rule") == 0; node = node->NextSiblingElement()) {
-                    Settings::Rule rule;
+                    Rule rule;
+                    Regex::Engine regexEngine = Regex::Engine::Pcre;
 
                     for (const tinyxml2::XMLElement *subnode = node->FirstChildElement(); subnode; subnode = subnode->NextSiblingElement()) {
                         const char * const subname = subnode->Name();
@@ -1373,7 +1375,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                         else if (std::strcmp(subname, "engine") == 0) {
                             const char * const engine = empty_if_null(subtext);
                             if (std::strcmp(engine, "pcre") == 0) {
-                                rule.engine = Regex::Engine::Pcre;
+                                regexEngine = Regex::Engine::Pcre;
                             }
                             else {
                                 mLogger.printError(std::string("unknown regex engine '") + engine + "'.");
@@ -1407,7 +1409,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                     }
 
                     std::string regex_err;
-                    auto regex = Regex::create(rule.pattern, rule.engine, regex_err);
+                    auto regex = Regex::create(rule.pattern, regexEngine, regex_err);
                     if (!regex) {
                         mLogger.printError("unable to load rule-file '" + ruleFile + "' - pattern '" + rule.pattern + "' failed to compile (" + regex_err + ").");
                         return Result::Fail;

cli/cmdlineparser.cpp

@@ -24,6 +24,10 @@
 #include "settings.h"
 #include "suppressions.h"
 
+#ifdef HAVE_RULES
+#include "rule.h"
+#endif
+
 #include <QFile>
 #include <QIODevice>
 #include <QList>
@@ -38,6 +42,7 @@ const char Settings::SafeChecks::XmlExternalFunctions[] = "external-functions";
 const char Settings::SafeChecks::XmlInternalFunctions[] = "internal-functions";
 const char Settings::SafeChecks::XmlExternalVariables[] = "external-variables";
 Settings::Settings() : maxCtuDepth(10) {}
+Settings::~Settings() = default;
 Platform::Platform() = default;
 Library::Library() = default;
 Library::~Library() = default;

gui/test/projectfile/testprojectfile.cpp

@@ -47,6 +47,7 @@
 
 #ifdef HAVE_RULES
 #include "regex.h"
+#include "rule.h"
 #endif
 
 #include <algorithm>
@@ -1415,7 +1416,7 @@ void CppCheck::checkNormalTokens(const Tokenizer &tokenizer, AnalyzerInformation
 #ifdef HAVE_RULES
 bool CppCheck::hasRule(const std::string &tokenlist) const
 {
-    return std::any_of(mSettings.rules.cbegin(), mSettings.rules.cend(), [&](const Settings::Rule& rule) {
+    return std::any_of(mSettings.rules.cbegin(), mSettings.rules.cend(), [&](const Rule& rule) {
         return rule.tokenlist == tokenlist;
     });
 }
@@ -1433,7 +1434,7 @@ void CppCheck::executeRules(const std::string &tokenlist, const TokenList &list)
         str += tok->str();
     }
 
-    for (const Settings::Rule &rule : mSettings.rules) {
+    for (const Rule &rule : mSettings.rules) {
         if (rule.tokenlist != tokenlist)
             continue;
 

lib/cppcheck.cpp

@@ -168,6 +168,7 @@
     <ClInclude Include="programmemory.h" />
     <ClInclude Include="regex.h" />
     <ClInclude Include="reverseanalyzer.h" />
+    <ClInclude Include="rule.h" />
     <ClInclude Include="sarifreport.h" />
     <ClInclude Include="settings.h" />
     <ClInclude Include="smallvector.h" />

lib/cppcheck.vcxproj

@@ -179,6 +179,10 @@ namespace {
         std::string compile();
         std::string match(const std::string& str, const MatchFn& matchFn) const override;
 
+        Engine engine() const override {
+            return Engine::Pcre;
+        }
+
     private:
         std::string mPattern;
         pcre* mRe{};
@@ -254,6 +258,7 @@ static T* createAndCompileRegex(std::string pattern, std::string& err)
     return regex;
 }
 
+// cppcheck-suppress shadowFunction - FP see #14802
 std::shared_ptr<Regex> Regex::create(std::string pattern, Engine engine, std::string& err)
 {
     Regex* regex = nullptr;

lib/regex.cpp

@@ -44,6 +44,8 @@ class CPPCHECKLIB Regex
         Pcre = 1
     };
 
+    virtual Engine engine() const = 0;
+
     static std::shared_ptr<Regex> create(std::string pattern, Engine engine, std::string& err);
 };
 

lib/regex.h

@@ -0,0 +1,43 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ruleH
+#define ruleH
+
+#ifdef HAVE_RULES
+
+#include "errortypes.h"
+
+#include <memory>
+#include <string>
+
+class Regex;
+
+/** Rule */
+struct Rule
+{
+    std::string tokenlist = "normal"; // use normal tokenlist
+    std::string pattern;
+    std::string id = "rule"; // default id
+    std::string summary;
+    Severity severity = Severity::style; // default severity
+    std::shared_ptr<Regex> regex;
+};
+#endif // HAVE_RULES
+
+#endif // ruleH

lib/rule.h

@@ -24,6 +24,10 @@
 #include "suppressions.h"
 #include "vfvalue.h"
 
+#ifdef HAVE_RULES
+#include "rule.h"
+#endif
+
 #include <cctype>
 #include <cstdlib>
 #include <cstring>
@@ -69,6 +73,14 @@ Settings::Settings()
     pid = getPid();
 }
 
+Settings::~Settings() = default;
+
+Settings::Settings(const Settings&) = default;
+Settings & Settings::operator=(const Settings &) = default;
+
+Settings::Settings(Settings&&) noexcept = default;
+Settings & Settings::operator=(Settings &&) noexcept = default;
+
 std::string Settings::loadCppcheckCfg(Settings& settings, Suppressions& suppressions, bool debug)
 {
     static const std::string cfgFilename = "cppcheck.cfg";

lib/settings.cpp

@@ -44,20 +44,13 @@
 #endif
 
 #ifdef HAVE_RULES
-#include "errortypes.h"
-#include "regex.h"
-
-#include <memory>
-
-class Regex;
-#else
-enum class Severity : std::uint8_t;
+struct Rule;
 #endif
-
 struct Suppressions;
 namespace ValueFlow {
     class Value;
 }
+enum class Severity : std::uint8_t;
 enum class Certainty : std::uint8_t;
 enum class Checks : std::uint8_t;
 
@@ -115,6 +108,13 @@ class CPPCHECKLIB WARN_UNUSED Settings {
 
 public:
     Settings();
+    ~Settings();
+
+    Settings(const Settings&);
+    Settings& operator=(const Settings&);
+
+    Settings(Settings&&) noexcept;
+    Settings& operator=(Settings&&) noexcept;
 
     static std::string loadCppcheckCfg(Settings& settings, Suppressions& suppressions, bool debug = false);
 
@@ -372,17 +372,6 @@ class CPPCHECKLIB WARN_UNUSED Settings {
     int reportProgress{-1};
 
 #ifdef HAVE_RULES
-    /** Rule */
-    struct CPPCHECKLIB Rule {
-        std::string tokenlist = "normal"; // use normal tokenlist
-        std::string pattern;
-        std::string id = "rule"; // default id
-        std::string summary;
-        Severity severity = Severity::style; // default severity
-        Regex::Engine engine = Regex::Engine::Pcre;
-        std::shared_ptr<Regex> regex;
-    };
-
     /**
      * @brief Extra rules
      */