Add lookahead to patterns

Author: praydog

include/utility/Pattern.hpp

@@ -6,6 +6,13 @@
 #include <vector>
 
 namespace utility {
+    inline constexpr size_t DEFAULT_GLOB_MAX_GAP = 256;
+
+    struct PatternSegment {
+        std::vector<int16_t> pattern;
+        size_t max_gap; // max gap BEFORE this segment (0 for first segment)
+    };
+
     class Pattern {
     public:
         Pattern() = delete;
@@ -19,10 +26,15 @@ namespace utility {
         Pattern& operator=(const Pattern& other) = default;
         Pattern& operator=(Pattern&& other) = default;
 
-        auto pattern_len() const noexcept { return m_pattern.size(); }
+        // Returns the length of the first segment (backward compat).
+        auto pattern_len() const noexcept { return m_segments[0].pattern.size(); }
+
+        bool is_multi_segment() const noexcept { return m_segments.size() > 1; }
 
     private:
-        std::vector<int16_t> m_pattern;
+        std::optional<uintptr_t> find_single(uintptr_t start, size_t length, const std::vector<int16_t>& pat);
+
+        std::vector<PatternSegment> m_segments;
     };
 
     // Converts a string pattern (eg. "90 90 ? EB ? ? ?" to a vector of int's where

src/Pattern.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <charconv>
 
 #include <Windows.h>
 
@@ -25,20 +26,83 @@ namespace utility {
     }
 
     Pattern::Pattern(const string& pattern)
-        : m_pattern{}
+        : m_segments{}
     {
-        m_pattern = buildPattern(pattern);
+        // Split pattern string at '*' tokens to produce segments.
+        // Syntax: "AA BB * CC DD" or "AA BB *128 CC DD" (max gap in bytes).
+        // Spaces around '*' are handled by splitting on whitespace tokens.
+
+        // Tokenize by spaces first so we can detect '*' and '*N' tokens.
+        std::vector<std::string> tokens;
+        {
+            size_t i = 0;
+            while (i < pattern.size()) {
+                while (i < pattern.size() && pattern[i] == ' ') ++i;
+                if (i >= pattern.size()) break;
+                size_t start = i;
+                while (i < pattern.size() && pattern[i] != ' ') ++i;
+                tokens.emplace_back(pattern.substr(start, i - start));
+            }
+        }
+
+        // Group tokens into segments separated by '*' / '*N' tokens.
+        std::vector<std::string> segment_strs;
+        std::vector<size_t> gap_sizes; // gap_sizes[i] = max gap before segment i
+
+        std::string current;
+        for (auto& tok : tokens) {
+            if (!tok.empty() && tok[0] == '*') {
+                // Flush current segment
+                segment_strs.push_back(std::move(current));
+                current.clear();
+
+                // Parse optional gap size: *[N]
+                size_t gap = DEFAULT_GLOB_MAX_GAP;
+                if (tok.size() > 2 && tok[1] == '[') {
+                    auto close = tok.find(']', 2);
+                    if (close != std::string::npos) {
+                        std::from_chars(tok.data() + 2, tok.data() + close, gap);
+                    }
+                }
+                gap_sizes.push_back(gap);
+            } else {
+                if (!current.empty()) current += ' ';
+                current += tok;
+            }
+        }
+        // Flush last segment
+        if (!current.empty()) {
+            segment_strs.push_back(std::move(current));
+        }
+
+        // Build each segment
+        for (size_t i = 0; i < segment_strs.size(); ++i) {
+            PatternSegment seg;
+            seg.pattern = buildPattern(segment_strs[i]);
+            seg.max_gap = (i < gap_sizes.size() + 1 && i > 0) ? gap_sizes[i - 1] : 0;
+            m_segments.push_back(std::move(seg));
+        }
+
+        // Fallback: if pattern was empty or something went wrong, push an empty segment
+        if (m_segments.empty()) {
+            m_segments.push_back(PatternSegment{{}, 0});
+        }
     }
 
-    optional<uintptr_t> Pattern::find(uintptr_t start, size_t length) {
-        auto patternLength = m_pattern.size();
+    optional<uintptr_t> Pattern::find_single(uintptr_t start, size_t length, const vector<int16_t>& pat) {
+        auto patternLength = pat.size();
+
+        if (patternLength == 0 || length < patternLength) {
+            return start; // Empty pattern matches immediately
+        }
+
         auto actual_end = start + length;
         auto end_scan_from = actual_end - patternLength;
 
         int32_t first_non_wildcard_index{-1};
 
-        for (size_t p = 0; p < m_pattern.size(); ++p) {
-            const auto k = m_pattern[p];
+        for (size_t p = 0; p < pat.size(); ++p) {
+            const auto k = pat[p];
             if (k != -1) {
                 first_non_wildcard_index = p;
                 break;
@@ -52,9 +116,7 @@ namespace utility {
         auto it_wildcard = (uint8_t*)start;
 
         do try {
-            // std::find can throw an exception if the memory is not readable.
-            // std::find also appears to be highly optimized compared to a manual loop which is why we use it.
-            it_wildcard = std::find((uint8_t*)it_wildcard, (uint8_t*)actual_end, (uint8_t)m_pattern[first_non_wildcard_index]);
+            it_wildcard = std::find((uint8_t*)it_wildcard, (uint8_t*)actual_end, (uint8_t)pat[first_non_wildcard_index]);
 
             auto it = it_wildcard - first_non_wildcard_index;
 
@@ -67,15 +129,7 @@ namespace utility {
             auto j = it;
             auto failedToMatch = false;
 
-            // Make sure the address is readable.
-            // Actually, don't do this. It's overhead (indirectly calls through a ptr)
-            // Our exception handler should be fine.
-            /*if (IsBadReadPtr((const void*)it, patternLength) != FALSE) {
-                it_wildcard += patternLength - 1;
-                continue;
-            }*/
-
-            for (auto& k : m_pattern) {
+            for (auto& k : pat) {
                 if (k != -1 && k != *(uint8_t*)j) {
                     failedToMatch = true;
                     break;
@@ -97,6 +151,66 @@ namespace utility {
         return {};
     }
 
+    optional<uintptr_t> Pattern::find(uintptr_t start, size_t length) {
+        if (m_segments.empty()) {
+            return {};
+        }
+
+        const auto actual_end = start + length;
+
+        // Fast path: single segment (no glob wildcards).
+        if (m_segments.size() == 1) {
+            return find_single(start, length, m_segments[0].pattern);
+        }
+
+        // Multi-segment: find first segment, then each subsequent segment
+        // within its max_gap window. On failure, retry with the next occurrence
+        // of the first segment.
+        auto search_start = start;
+
+        while (search_start < actual_end) {
+            const auto remaining = actual_end - search_start;
+            auto seg0_result = find_single(search_start, remaining, m_segments[0].pattern);
+
+            if (!seg0_result) {
+                return {};
+            }
+
+            const auto match_start = *seg0_result;
+            auto cursor = match_start + m_segments[0].pattern.size();
+            bool all_found = true;
+
+            for (size_t i = 1; i < m_segments.size(); ++i) {
+                const auto& seg = m_segments[i];
+                const auto seg_len = seg.pattern.size();
+                const auto window_end = (std::min)(cursor + seg.max_gap + seg_len, actual_end);
+
+                if (cursor >= window_end || window_end - cursor < seg_len) {
+                    all_found = false;
+                    break;
+                }
+
+                auto seg_result = find_single(cursor, window_end - cursor, seg.pattern);
+
+                if (!seg_result) {
+                    all_found = false;
+                    break;
+                }
+
+                cursor = *seg_result + seg_len;
+            }
+
+            if (all_found) {
+                return match_start;
+            }
+
+            // Retry from after the failed first-segment match
+            search_start = match_start + 1;
+        }
+
+        return {};
+    }
+
     vector<int16_t> buildPattern(string patternStr) {
         // Remove spaces from the pattern string.
         patternStr.erase(remove_if(begin(patternStr), end(patternStr), isspace), end(patternStr));