fixed #14261 - Regex: added std::regex implementation [skip ci]

firewave · firewave · commit d818c3edc6e7 · 2026-07-09T10:38:16.000+02:00
diff --git a/cli/cmdlineparser.cpp b/cli/cmdlineparser.cpp
@@ -1317,7 +1317,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
             }
 
             std::string regex_err;
-            auto regex = Regex::create(rule.pattern, Regex::Engine::Pcre, regex_err);
+            auto regex = Regex::create(rule.pattern, Regex::defaultEngine(), regex_err);
             if (!regex) {
                 mLogger.printError("failed to compile rule pattern '" + rule.pattern + "' (" + regex_err + ").");
                 return Result::Fail;
@@ -1345,7 +1345,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                     node = node->FirstChildElement("rule");
                 for (; node && strcmp(node->Value(), "rule") == 0; node = node->NextSiblingElement()) {
                     Rule rule;
-                    Regex::Engine regexEngine = Regex::Engine::Pcre;
+                    Regex::Engine regexEngine = Regex::defaultEngine();
 
                     for (const tinyxml2::XMLElement *subnode = node->FirstChildElement(); subnode; subnode = subnode->NextSiblingElement()) {
                         const char * const subname = subnode->Name();
@@ -1377,10 +1377,8 @@ 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) {
-                                regexEngine = Regex::Engine::Pcre;
-                            }
-                            else {
+                            if (!Regex::stringToEngine(engine, regexEngine))
+                            {
                                 mLogger.printError(std::string("unknown regex engine '") + engine + "'.");
                                 return Result::Fail;
                             }
diff --git a/cmake/compilerDefinitions.cmake b/cmake/compilerDefinitions.cmake
@@ -37,6 +37,12 @@ endif()
 
 if(HAVE_RULES)
     add_definitions(-DHAVE_RULES)
+    if(HAVE_PCRE)
+        add_definitions(-DHAVE_PCRE)
+    endif()
+    if(HAVE_STD_REGEX)
+        add_definitions(-DHAVE_STD_REGEX)
+    endif()
 endif()
 
 if(Boost_FOUND)
diff --git a/cmake/options.cmake b/cmake/options.cmake
@@ -94,7 +94,33 @@ if(NOT BUILD_GUI)
     endif()
 endif()
 
-option(HAVE_RULES           "Usage of rules (needs PCRE library and headers)"               OFF)
+option(HAVE_RULES           "Usage of rules"                                                OFF)
+option(HAVE_PCRE            "Allow usage of PCRE in rules"                                  OFF)
+option(HAVE_STD_REGEX       "Allow usage of std::regex in rules"                            OFF)
+# TODO: add option to specify default regular expression engine
+if(NOT HAVE_RULES)
+    if(HAVE_PCRE)
+        message(WARNING "HAVE_PCRE has no effect without HAVE_RULES")
+    endif()
+    if(HAVE_STD_REGEX)
+        message(WARNING "HAVE_STD_REGEX has no effect without HAVE_RULES")
+    endif()
+endif()
+if(HAVE_RULES)
+    # TODO: handle explicit HAVE_PCRE parameter
+    message(DEPRECATION "HAVE_RULES will no longer explicitly enable HAVE_PCRE with Cppcheck 2.24")
+    set(HAVE_PCRE ON)
+
+    # TODO: unconditionally enable for all other build?
+    if(MSVC AND HAVE_STD_REGEX)
+        message(WARNING "Disabling usage of std::regex since its implementation is broken in Visual Studio")
+        set(HAVE_STD_REGEX OFF)
+    endif()
+
+    if(NOT HAVE_PCRE AND NOT HAVE_STD_REGEX)
+        message(FATAL_ERROR "Cannot use rules since no regular expression engine is available")
+    endif()
+endif()
 option(USE_BUNDLED_TINYXML2 "Usage of bundled TinyXML2 library"                             ON)
 if(BUILD_CORE_DLL AND NOT USE_BUNDLED_TINYXML2)
     message(FATAL_ERROR "Cannot use external TinyXML2 library when building lib as DLL")
diff --git a/cmake/printInfo.cmake b/cmake/printInfo.cmake
@@ -79,7 +79,12 @@ endif()
 message(STATUS)
 message(STATUS "HAVE_RULES =            ${HAVE_RULES}")
 if(HAVE_RULES)
-    message(STATUS "PCRE_LIBRARY =          ${PCRE_LIBRARY}")
+    message(STATUS "HAVE_PCRE =             ${HAVE_PCRE}")
+    if(HAVE_PCRE)
+        message(STATUS "PCRE_INCLUDE =          ${PCRE_INCLUDE}")
+        message(STATUS "PCRE_LIBRARY =          ${PCRE_LIBRARY}")
+    endif()
+    message(STATUS "HAVE_STD_REGEX =        ${HAVE_STD_REGEX}")
 endif()
 message(STATUS)
 message(STATUS "DISALLOW_THREAD_EXECUTOR = ${DISALLOW_THREAD_EXECUTOR}")
diff --git a/lib/regex.cpp b/lib/regex.cpp
@@ -22,11 +22,29 @@
 
 #include <utility>
 
+#if defined(HAVE_STD_REGEX)
+#include <regex>
+#endif
+
+#if defined(HAVE_PCRE)
 #ifdef _WIN32
 #define PCRE_STATIC
 #endif
 #include <pcre.h>
+#endif
 
+enum class Regex::Engine : std::uint8_t
+{
+    Unknown = 0,
+#if defined(HAVE_PCRE)
+    Pcre = 1,
+#endif
+#if defined(HAVE_STD_REGEX)
+    Std = 2
+#endif
+};
+
+#if defined(HAVE_PCRE)
 namespace {
     std::string pcreErrorCodeToString(const int pcreExecRet)
     {
@@ -249,6 +267,58 @@ namespace {
         return "";
     }
 }
+#endif // HAVE_PCRE
+
+#if defined(HAVE_STD_REGEX)
+namespace {
+    class StdRegex : public Regex
+    {
+    public:
+        explicit StdRegex(std::string pattern)
+            : mPattern(std::move(pattern))
+        {}
+
+        std::string compile()
+        {
+            if (mCompiled)
+                return "regular expression has already been compiled";
+
+            try {
+                mRegex = std::regex(mPattern);
+            } catch (const std::exception& e) {
+                return e.what();
+            }
+            mCompiled = true;
+            return "";
+        }
+
+        std::string match(const std::string& str, const MatchFn& matchFn) const override
+        {
+            if (!mCompiled)
+                return "regular expression has not been compiled yet";
+
+            auto I = std::sregex_iterator(str.cbegin(), str.cend(), mRegex);
+            const auto E = std::sregex_iterator();
+            while (I != E)
+            {
+                const std::smatch& match = *I;
+                matchFn(match.position(), match.position() + match.length());
+                ++I;
+            }
+            return "";
+        }
+
+        Engine engine() const override {
+            return Engine::Std;
+        }
+
+    private:
+        std::string mPattern;
+        std::regex mRegex;
+        bool mCompiled{};
+    };
+}
+#endif // HAVE_STD_REGEX
 
 template<typename T>
 static T* createAndCompileRegex(std::string pattern, std::string& err)
@@ -261,10 +331,21 @@ static T* createAndCompileRegex(std::string pattern, std::string& err)
 std::shared_ptr<Regex> Regex::create(std::string pattern, Engine engine, std::string& err)
 {
     Regex* regex = nullptr;
-    if (engine == Engine::Pcre)
-        regex = createAndCompileRegex<PcreRegex>(std::move(pattern), err);
-    else {
-        err = "unknown regular expression engine";
+    switch(engine)
+    {
+#if defined(HAVE_PCRE)
+        case Engine::Pcre:
+            regex = createAndCompileRegex<PcreRegex>(std::move(pattern), err);
+            break;
+#endif
+#if defined(HAVE_STD_REGEX)
+        case Engine::Std:
+            regex = createAndCompileRegex<StdRegex>(std::move(pattern), err);
+            break;
+#endif
+        default:
+            err = "unknown regular expression engine";
+            break;
     }
     if (!err.empty()) {
         delete regex;
@@ -273,4 +354,27 @@ std::shared_ptr<Regex> Regex::create(std::string pattern, Engine engine, std::st
     return std::shared_ptr<Regex>(regex);
 }
 
+bool Regex::stringToEngine(const char* engine, Regex::Engine& regexEngine)
+{
+#if defined(HAVE_PCRE)
+    if (std::strcmp(engine, "pcre") == 0) {
+        regexEngine = Regex::Engine::Pcre;
+        return true;
+    }
+#endif
+#if defined(HAVE_STD_REGEX)
+    if (std::strcmp(engine, "std") == 0) {
+        regexEngine = Regex::Engine::Std;
+        return true;
+    }
+#endif
+    regexEngine = Regex::Engine::Unknown;
+    return false;
+}
+
+Regex::Engine Regex::defaultEngine()
+{
+    return Regex::Engine::Pcre;
+}
+
 #endif // HAVE_RULES
diff --git a/lib/regex.h b/lib/regex.h
@@ -33,20 +33,19 @@
 class CPPCHECKLIB Regex
 {
 public:
+    enum class Engine : std::uint8_t;
+
     virtual ~Regex() = default;
 
     using MatchFn = std::function<void (int start, int end)>;
     virtual std::string match(const std::string& str, const MatchFn& matchFn) const = 0;
 
-    enum class Engine : std::uint8_t
-    {
-        Unknown = 0,
-        Pcre = 1
-    };
-
     virtual Engine engine() const = 0;
 
     static std::shared_ptr<Regex> create(std::string pattern, Engine engine, std::string& err);
+
+    static bool stringToEngine(const char* engine, Regex::Engine& regexEngine);
+    static Engine defaultEngine();
 };
 
 #endif // HAVE_RULES
diff --git a/releasenotes.txt b/releasenotes.txt
@@ -21,4 +21,6 @@ Infrastructure & dependencies:
 -
 
 Other:
+- Added support for `std::regex` as the regular engine for rules. It can be specified using `std` in the engine` element in a rule XML.
+-
 -
diff --git a/test/testcmdlineparser.cpp b/test/testcmdlineparser.cpp
@@ -2729,6 +2729,7 @@ class TestCmdlineParser : public TestFixture {
                         "</message>\n"
                         "</rule>\n"
                         "<rule>\n"
+                        "<engine>std</engine>\n"
                         "<tokenlist>define</tokenlist>\n"
                         "<pattern>.*</pattern>\n"
                         "<message>\n"
@@ -2749,7 +2750,7 @@ class TestCmdlineParser : public TestFixture {
         ASSERT_EQUALS("ruleId1", it->id);
         ASSERT_EQUALS("ruleSummary1", it->summary);
         ++it;
-        ASSERT_EQUALS_ENUM(Regex::Engine::Pcre, it->regex->engine());
+        ASSERT_EQUALS_ENUM(Regex::Engine::Std, it->regex->engine());
         ASSERT_EQUALS("define", it->tokenlist);
         ASSERT_EQUALS(".*", it->pattern);
         ASSERT_EQUALS_ENUM(Severity::warning, it->severity);
diff --git a/test/testregex.cpp b/test/testregex.cpp
@@ -87,6 +87,18 @@ class TestRegExBase : public TestFixture {
         std::string exp;
         if (mEngine == Regex::Engine::Pcre)
             exp = "missing terminating ] for character class";
+        else if (mEngine == Regex::Engine::Std)
+        {
+#if defined(_MSC_VER)
+            exp = "regex_error(error_brack): The expression contained mismatched [ and ].";
+#elif defined(_LIBCPP_VERSION)
+            exp = "The expression contained mismatched [ and ].";
+#elif defined(__clang__)
+            exp = "Unexpected character within '[...]' in regular expression";
+#else
+            exp = "Unexpected character in bracket expression.";
+#endif
+        }
 
         (void)assertRegex("[", exp);
     }
@@ -203,6 +215,12 @@ class TestRegExPcre : public TestRegExBase {
     TestRegExPcre() : TestRegExBase("TestRegExPcre", Regex::Engine::Pcre) {}
 };
 
+class TestRegExStd : public TestRegExBase {
+public:
+    TestRegExStd() : TestRegExBase("TestRegExStd", Regex::Engine::Std) {}
+};
+
 REGISTER_TEST(TestRegExPcre)
+REGISTER_TEST(TestRegExStd)
 
 #endif // HAVE_RULES

Original file line number	Diff line number	Diff line change
`@@ -21,4 +21,6 @@ Infrastructure & dependencies:`
`21`	`21`	`-`
`22`	`22`
`23`	`23`	`Other:`
	`24`	+- Added support for `std::regex` as the regular engine for rules. It can be specified using `std` in the engine` element in a rule XML.
	`25`	`+-`
`24`	`26`	`-`