StringScanner.hpp

#pragma once
#include <vector>
#include <string>
#include <cstdint>
#include <algorithm>
#include <unordered_map>

class StringScanner {
public:
    //The string scanner uses the boyer horspoll algorithm
    static std::vector<uintptr_t> SearchBMH(const uint8_t* data, size_t dataSize,
        const std::string& pattern, bool caseSensitive = true) {
        std::vector<uintptr_t> results;

        if (pattern.empty() || dataSize < pattern.length()) {
            return results;
        }

        std::string searchPattern = pattern;
        if (!caseSensitive) {
            std::transform(searchPattern.begin(), searchPattern.end(),
                searchPattern.begin(), ::tolower);
        }

        size_t patternLen = searchPattern.length();
        size_t dataLen = dataSize;

        //preprocesser
        std::unordered_map<char, size_t> badCharShift;
        for (size_t i = 0; i < patternLen - 1; ++i) {
            badCharShift[searchPattern[i]] = patternLen - i - 1;
        }

        size_t i = 0;
        while (i <= dataLen - patternLen) {
            int j = static_cast<int>(patternLen) - 1;

            while (j >= 0) {
                char dataChar = static_cast<char>(data[i + j]);
                if (!caseSensitive) {
                    dataChar = static_cast<char>(::tolower(dataChar));
                }

                if (dataChar != searchPattern[j]) {
                    break;
                }
                j--;
            }

            if (j < 0) {
                // matched
                results.push_back(i);
                i += patternLen;
            }
            else {

                char dataChar = static_cast<char>(data[i + j]);
                if (!caseSensitive) {
                    dataChar = static_cast<char>(::tolower(dataChar));
                }

                auto it = badCharShift.find(dataChar);
                size_t shift = (it != badCharShift.end()) ? it->second : patternLen;
                i += std::max<size_t>(1, shift - (patternLen - 1 - j));
            }
        }

        return results;
    }

    //multi search
    static std::vector<std::pair<std::string, uintptr_t>>
        SearchMultiple(const uint8_t* data, size_t dataSize,
            const std::vector<std::string>& patterns,
            bool caseSensitive = true) {

        std::vector<std::pair<std::string, uintptr_t>> results;

        for (const auto& pattern : patterns) {
            auto patternResults = SearchBMH(data, dataSize, pattern, caseSensitive);
            for (auto offset : patternResults) {
                results.emplace_back(pattern, offset);
            }
        }

        return results;
    }
};