Hand-written matching function

Author: glankk

lib/pathmatch.cpp

@@ -20,42 +20,100 @@
 
 #include "path.h"
 
-#include <cstddef>
-#include <cstring>
+#include <algorithm>
+#include <cctype>
+#include <stack>
 #include <string>
-#include <regex>
+#include <vector>
 
-/* Escape regex special chars and translate globs to equivalent regex */
-static std::string translate(const std::string &s)
+static bool match_one(const std::string &pattern, const std::string &path, PathMatch::Mode mode)
 {
-    std::string r;
-    std::size_t i = 0;
-
-    while (i != s.size()) {
-        int c = s[i++];
-
-        if (std::strchr("\\[](){}+^$|", c) != nullptr) {
-            r.push_back('\\');
-            r.push_back(c);
-        } else if (c == '*') {
-            if (i != s.size() && s[i] == '*') {
-                r.append(".*");
-                i++;
+    if (pattern.size() == 0 || path.size() == 0)
+        return false;
+
+    bool abs = Path::isAbsolute(pattern);
+
+    std::stack<std::pair<const char *, const char *>> b;
+
+    const char *s = pattern.c_str();
+    const char *t = path.c_str();
+    const char *r = t;
+
+    for (;;) {
+        switch (*s) {
+            case '*': {
+                bool slash = false;
+                s++;
+                if (*s == '*') {
+                    slash = true;
+                    s++;
+                }
+                b.emplace(s, t);
+                while (*t != '\0' && (slash || *t != '/')) {
+                    if (*s == *t)
+                        b.emplace(s, t);
+                    t++;
+                }
+                continue;
             }
-            else {
-                r.append("[^/]*");
+            case '?': {
+                if (*t != '\0' && *t != '/') {
+                    s++;
+                    t++;
+                    continue;
+                }
+                break;
+            }
+            case '/': {
+                s++;
+                if (*s == '\0' && (*t == '\0' || *t == '/'))
+                    return true;
+                if (*t == '/') {
+                    t++;
+                    continue;
+                }
+                break;
+            }
+            case '\0': {
+                if (*t == '\0' || *t == '/')
+                    return true;
+                break;
+            }
+            default: {
+                if (*s == *t || (mode == PathMatch::Mode::icase && std::tolower(*s) == std::tolower(*t))) {
+                    s++;
+                    t++;
+                    continue;
+                }
+                break;
+            }
+        }
+
+        if (b.size() != 0) {
+            const auto &bp = b.top();
+            b.pop();
+            s = bp.first;
+            t = bp.second;
+            continue;
+        }
+
+        if (!abs) {
+            while (*r != '\0' && *r != '/')
+                r++;
+            if (*r == '/') {
+                r++;
+                s = pattern.c_str();
+                t = r;
+                continue;
             }
-        } else if (c == '?') {
-            r.append("[^/]");
-        } else {
-            r.push_back(c);
         }
-    }
 
-    return r;
+        return false;
+    }
 }
 
-PathMatch::PathMatch(const std::vector<std::string> &paths, const std::string &basepath, Mode mode)
+PathMatch::PathMatch(std::vector<std::string> patterns, const std::string &basepath, Mode mode) :
+    mPatterns(std::move(patterns)), mMode(mode)
 {
     if (basepath.empty())
         mBasepath = Path::getCurrentPath();
@@ -64,57 +122,35 @@ PathMatch::PathMatch(const std::vector<std::string> &paths, const std::string &b
     else
         mBasepath = Path::getCurrentPath() + "/" + basepath;
 
-    if (mode == Mode::platform) {
+    if (mMode == Mode::platform) {
 #ifdef _WIN32
-        mode = Mode::icase;
+        mMode = Mode::icase;
 #else
-        mode = Mode::scase;
+        mMode = Mode::scase;
 #endif
     }
 
-    std::string regex_string;
-
-    for (auto p : paths) {
+    for (auto &p : mPatterns) {
         if (p.empty())
             continue;
 
-        if (!regex_string.empty())
-            regex_string.push_back('|');
-
         if (p.front() == '.')
             p = mBasepath + "/" + p;
 
         p = Path::fromNativeSeparators(Path::simplifyPath(p));
-
-        if (p.back() == '/')
-            p.pop_back();
-
-        if (Path::isAbsolute(p))
-            regex_string.push_back('^');
-        else
-            regex_string.push_back('/');
-
-        regex_string.append(translate(p) + "(/|$)");
     }
-
-    if (regex_string.empty())
-        return;
-
-    if (mode == Mode::icase)
-        mRegex = std::regex(regex_string, std::regex_constants::extended | std::regex_constants::icase);
-    else
-        mRegex = std::regex(regex_string, std::regex_constants::extended);
 }
 
 bool PathMatch::match(const std::string &path) const
 {
-    std::string p;
-    std::smatch m;
+    std::string matchpath;
 
     if (Path::isAbsolute(path))
-        p = Path::fromNativeSeparators(Path::simplifyPath(path));
+        matchpath = Path::fromNativeSeparators(Path::simplifyPath(path));
     else
-        p = Path::fromNativeSeparators(Path::simplifyPath(mBasepath + "/" + path));
+        matchpath = Path::fromNativeSeparators(Path::simplifyPath(mBasepath + "/" + path));
 
-    return std::regex_search(p, m, mRegex, std::regex_constants::match_any | std::regex_constants::match_not_null);
+    return std::any_of(mPatterns.cbegin(), mPatterns.cend(), [this, &matchpath] (const std::string &pattern) {
+        return match_one(pattern, matchpath, mMode);
+    });
 }

lib/pathmatch.h

@@ -22,7 +22,6 @@
 #include "config.h"
 
 #include <cstdint>
-#include <regex>
 #include <string>
 #include <vector>
 
@@ -31,24 +30,24 @@
 
 /**
  *  Path matching rules:
- *  - All rules are simplified first (path separators vary by platform):
+ *  - All patterns are simplified first (path separators vary by platform):
  *    - '/./' => '/'
  *    - '/dir/../' => '/'
  *    - '//' => '/'
  *    - Trailing slashes are removed
- *  - Rules can contain globs:
+ *  - Patterns can contain globs:
  *    - '**' matches any number of characters including path separators.
  *    - '*' matches any number of characters except path separators.
  *    - '?' matches any single character except path separators.
- *  - If a rule looks like an absolute path (e.g. starts with '/', but varies by platform):
- *    - Match all files where the rule matches the start of the file's simplified absolute path up until a path
+ *  - If a pattern looks like an absolute path (e.g. starts with '/', but varies by platform):
+ *    - Match all files where the pattern matches the start of the file's simplified absolute path up until a path
  *      separator or the end of the pathname.
- *  - If a rule starts with '.':
- *    - The rule is interpreted as a path relative to `basepath` and then converted to an absolute path and
- *      treated as such according to the above procedure. If the rule is relative to some other directory, it should
- *      be modified to be relative to `basepath` first (this should be done with rules in project files, for example).
+ *  - If a pattern starts with '.':
+ *    - The pattern is interpreted as a path relative to `basepath` and then converted to an absolute path and
+ *      treated as such according to the above procedure. If the pattern is relative to some other directory, it should
+ *      be modified to be relative to `basepath` first (this should be done with patterns in project files, for example).
  *  - Otherwise:
- *    - Match all files where the rule matches any part of the file's simplified absolute path up until a
+ *    - Match all files where the pattern matches any part of the file's simplified absolute path up until a
  *      path separator or the end of the pathname, and the matching part directly follows a path separator.
  **/
 
@@ -74,28 +73,25 @@ class CPPCHECKLIB PathMatch {
     /**
      * The constructor.
      *
-     * If a path is a directory it needs to end with a file separator.
-     *
-     * @param paths List of masks.
-     * @param basepath Path to which rules and matched paths are relative, when applicable. Can be relative, in which
+     * @param patterns List of patterns.
+     * @param basepath Path to which patterns and matched paths are relative, when applicable. Can be relative, in which
      * case it is appended to Path::getCurrentPath().
      * @param mode Case sensitivity mode.
      */
-    explicit PathMatch(const std::vector<std::string> &paths, const std::string &basepath = std::string(), Mode mode = Mode::platform);
+    explicit PathMatch(std::vector<std::string> patterns, const std::string &basepath = std::string(), Mode mode = Mode::platform);
 
     /**
-     * @brief Match path against list of masks.
-     *
-     * If you want to match a directory the given path needs to end with a path separator.
+     * @brief Match path against list of patterns.
      *
      * @param path Path to match.
      * @return true if any of the masks match the path, false otherwise.
      */
     bool match(const std::string &path) const;
 
 private:
+    std::vector<std::string> mPatterns;
     std::string mBasepath;
-    std::regex mRegex;
+    Mode mMode;
 };
 
 /// @}