added engine to rule XML to specify regex engine (danmar#8383)

Author: firewave

.github/workflows/valgrind.yml

@@ -51,7 +51,7 @@ jobs:
       - name: Run valgrind
         run: |
           ec=0
-          valgrind --error-limit=yes --leak-check=full --num-callers=50 --show-reachable=yes --track-origins=yes --suppressions=valgrind/testrunner.supp --gen-suppressions=all -s --log-fd=9 --error-exitcode=42 ./testrunner TestGarbage TestOther TestSimplifyTemplate TestRegEx 9>memcheck.log || ec=1
+          valgrind --error-limit=yes --leak-check=full --num-callers=50 --show-reachable=yes --track-origins=yes --suppressions=valgrind/testrunner.supp --gen-suppressions=all -s --log-fd=9 --error-exitcode=42 ./testrunner TestGarbage TestOther TestSimplifyTemplate TestRegExPcre 9>memcheck.log || ec=1
           cat memcheck.log
           exit $ec
         # TODO: debuginfod.ubuntu.com is currently not responding to any requests causing it to run into a 40(!) minute timeout

Makefile

@@ -1294,7 +1294,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
             }
 
             std::string regex_err;
-            auto regex = Regex::create(rule.pattern, regex_err);
+            auto regex = Regex::create(rule.pattern, Regex::Engine::Pcre, regex_err);
             if (!regex) {
                 mLogger.printError("failed to compile rule pattern '" + rule.pattern + "' (" + regex_err + ").");
                 return Result::Fail;
@@ -1351,6 +1351,16 @@ 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;
+                            }
+                            else {
+                                mLogger.printError(std::string("unknown regex engine '") + engine + "'.");
+                                return Result::Fail;
+                            }
+                        }
                         else {
                             mLogger.printError("unable to load rule-file '" + ruleFile + "' - unknown element '" + subname + "' encountered in 'rule'.");
                             return Result::Fail;
@@ -1378,7 +1388,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                     }
 
                     std::string regex_err;
-                    auto regex = Regex::create(rule.pattern, regex_err);
+                    auto regex = Regex::create(rule.pattern, rule.engine, 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

@@ -188,15 +188,15 @@ namespace {
     std::string PcreRegex::compile()
     {
         if (mRe)
-            return "pcre_compile failed: regular expression has already been compiled";
+            return "regular expression has already been compiled";
 
         const char *pcreCompileErrorStr = nullptr;
         int erroffset = 0;
         pcre * const re = pcre_compile(mPattern.c_str(),0,&pcreCompileErrorStr,&erroffset,nullptr);
         if (!re) {
             if (pcreCompileErrorStr)
-                return "pcre_compile failed: " + std::string(pcreCompileErrorStr);
-            return "pcre_compile failed: unknown error";
+                return pcreCompileErrorStr;
+            return "unknown error";
         }
 
         // Optimize the regex, but only if PCRE_CONFIG_JIT is available
@@ -209,7 +209,7 @@ namespace {
         if (pcreStudyErrorStr) {
             // pcre_compile() worked, but pcre_study() returned an error. Free the resources allocated by pcre_compile().
             pcre_free(re);
-            return "pcre_study failed: " + std::string(pcreStudyErrorStr);
+            return std::string(pcreStudyErrorStr) + " (pcre_study)";
         }
         mExtra = pcreExtra;
 #endif
@@ -222,7 +222,7 @@ namespace {
     std::string PcreRegex::match(const std::string& str, const MatchFn& match) const
     {
         if (!mRe)
-            return "pcre_exec failed: regular expression has not been compiled yet";
+            return "regular expression has not been compiled yet";
 
         int pos = 0;
         int ovector[30]= {0};
@@ -231,7 +231,7 @@ namespace {
             if (pcreExecRet == PCRE_ERROR_NOMATCH)
                 return "";
             if (pcreExecRet < 0) {
-                return "pcre_exec failed (pos: " + std::to_string(pos) + "): " + pcreErrorCodeToString(pcreExecRet);
+                return pcreErrorCodeToString(pcreExecRet) + " (pos: " + std::to_string(pos) + ")";
             }
             const auto pos1 = static_cast<unsigned int>(ovector[0]);
             const auto pos2 = static_cast<unsigned int>(ovector[1]);
@@ -246,10 +246,22 @@ namespace {
     }
 }
 
-std::shared_ptr<Regex> Regex::create(std::string pattern, std::string& err)
+template<typename T>
+static T* createAndCompileRegex(std::string pattern, std::string& err)
 {
-    auto* regex = new PcreRegex(std::move(pattern));
+    T* regex = new T(std::move(pattern));
     err = regex->compile();
+    return regex;
+}
+
+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";
+    }
     if (!err.empty()) {
         delete regex;
         return nullptr;

lib/regex.cpp

@@ -25,6 +25,7 @@
 
 #include "config.h"
 
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
@@ -37,7 +38,13 @@ class CPPCHECKLIB Regex
     using MatchFn = std::function<void (int start, int end)>;
     virtual std::string match(const std::string& str, const MatchFn& matchFn) const = 0;
 
-    static std::shared_ptr<Regex> create(std::string pattern, std::string& err);
+    enum class Engine : std::uint8_t
+    {
+        Unknown = 0,
+        Pcre = 1
+    };
+
+    static std::shared_ptr<Regex> create(std::string pattern, Engine engine, std::string& err);
 };
 
 #endif // HAVE_RULES

lib/regex.h

@@ -40,6 +40,8 @@
 #include <unordered_set>
 #include <utility>
 
+#include "regex.h"
+
 #if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
 #include <cstdio>
 #endif
@@ -371,6 +373,7 @@ class CPPCHECKLIB WARN_UNUSED Settings {
         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;
     };