Implemented a wildcard matching function for filtering files in a directory.

end2endzone · end2endzone · commit da86472f4da4 · 2025-05-03T15:52:46.000-04:00
diff --git a/src/bin2cpp/CMakeLists.txt b/src/bin2cpp/CMakeLists.txt
@@ -28,6 +28,8 @@ add_executable(bin2cpp
   SegmentGenerator.h
   StringGenerator.cpp
   StringGenerator.h
+  wildcard.cpp
+  wildcard.h
   Win32ResourceGenerator.cpp
   Win32ResourceGenerator.h
 )
diff --git a/src/bin2cpp/wildcard.cpp b/src/bin2cpp/wildcard.cpp
@@ -0,0 +1,143 @@
+/**********************************************************************************
+ * MIT License
+ * 
+ * Copyright (c) 2018 Antoine Beauchamp
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *********************************************************************************/
+
+#include "wildcard.h"
+#include "bin2cpp/version.h"
+
+namespace bin2cpp
+{
+  static inline bool isdigit(const char& c)
+  {
+    return '0' <= c && c <= '9';
+  }
+
+  ///<param name="value_index">The search index within the value string.</param>
+  ///<param name="pattern_index">The search index within the pattern string.</param>
+  bool wildcard_match_helper(const std::string& value, const std::string& pattern, size_t value_index, size_t pattern_index, std::vector<std::string>& captures)
+  {
+    // Base case: value and pattern are both exhausted. All characrters matches.
+    if ( value_index == value.size() && pattern_index == pattern.size() )
+    {
+      return true;
+    }
+
+    // If pattern is exhausted but value has more characters, no match
+    if ( pattern_index == pattern.size() ) return false;
+
+    // Handle '*': Capture a variable-length substring
+    if ( pattern[pattern_index] == '*' )
+    {
+      for ( size_t i = value_index; i <= value.size(); ++i )
+      {
+        captures.push_back(value.substr(value_index, i - value_index));
+
+        // Recurse to resolve for the remaining characters.
+        bool match = wildcard_match_helper(value, pattern, i, pattern_index + 1, captures);
+        if ( match ) return true;
+        captures.pop_back(); // Remove last match if unsuccessful
+      }
+      return false;
+    }
+
+    // Handle '?': Capture a single character.
+    if ( value_index < value.size() && pattern[pattern_index] == '?' )
+    {
+      captures.push_back(std::string(1, value[value_index])); // Store single-character match
+
+      // Recurse to resolve for the remaining characters.
+      bool match = wildcard_match_helper(value, pattern, value_index + 1, pattern_index + 1, captures);
+      return match;
+    }
+
+    // Handle '#': Capture any single digit (0-9)
+    if ( value_index < value.size() && pattern[pattern_index] == '#' && isdigit(value[value_index]) )
+    {
+      captures.push_back(std::string(1, value[value_index]));
+
+      // Recurse to resolve for the remaining characters.
+      bool match = wildcard_match_helper(value, pattern, value_index + 1, pattern_index + 1, captures);
+      return match;
+    }
+
+    // Handling character lists like '[xyz]' or ranges like '[a-z]'.
+    // This assumes that first range character is smaller than second range character.
+    if ( pattern[pattern_index] == '[' )
+    {
+      size_t closing_bracket_pos = pattern.find(']', pattern_index);
+      if ( closing_bracket_pos == std::string::npos ) return false; // Malformed pattern
+
+      char matchChar = value[value_index];
+      bool found = false;
+
+      // For each characters in within the brackets
+      for ( size_t i = pattern_index + 1; i < closing_bracket_pos; ++i )
+      {
+        // Is this a range?
+        if ( pattern[i] == '-' && i > pattern_index + 1 && i < closing_bracket_pos - 1 )
+        {
+          // Handle range [x-y]
+          if ( matchChar >= pattern[i - 1] && matchChar <= pattern[i + 1] ) found = true;
+        }
+        else if ( pattern[i] == matchChar )
+        {
+          found = true;
+        }
+      }
+
+      // If match is found, capture it and continue recursion
+      if ( found )
+      {
+        captures.push_back(std::string(1, matchChar));
+
+        // Recurse to resolve for the remaining characters.
+        bool match = wildcard_match_helper(value, pattern, value_index + 1, closing_bracket_pos + 1, captures);
+        return match;
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    // Exact character match
+    if ( value_index < value.size() && pattern[pattern_index] == value[value_index] )
+    {
+      // Recurse to resolve for the remaining characters.
+      bool match = wildcard_match_helper(value, pattern, value_index + 1, pattern_index + 1, captures);
+      return match;
+    }
+
+    return false;
+  }
+
+  bool wildcard_match(const std::string& value, const std::string& pattern, std::vector<std::string>& captures)
+  {
+    captures.clear();  // Ensure captures vector is empty before starting
+    bool match = wildcard_match_helper(value, pattern, 0, 0, captures);
+    if ( !match )
+      captures.clear();
+    return match;
+  }
+
+}; //bin2cpp
diff --git a/src/bin2cpp/wildcard.h b/src/bin2cpp/wildcard.h
@@ -0,0 +1,75 @@
+/**********************************************************************************
+ * MIT License
+ * 
+ * Copyright (c) 2018 Antoine Beauchamp
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *********************************************************************************/
+
+#ifndef BIN2CPP_WILDCARD_H
+#define BIN2CPP_WILDCARD_H
+
+#include <string>
+#include <vector>
+
+namespace bin2cpp
+{
+
+  ///<summary>
+  ///Checks if a given value matches a pattern containing wildcard characters definition.
+  ///</summary>
+  ///<remarks>
+  ///  Supported Wildcards :
+  ///  -'?' matches any single character.
+  ///  -'*' matches zero or more characters.
+  ///  -'#' matches any single digit(0 - 9).
+  ///  -'[charlist]' matches any character in the provided set.
+  ///  -'[a-z]', '[A-Z]', '[0-9]' match characters in respective ranges.
+  ///  -'[a-zA-Z0-9]' matches any alphanumeric character.
+  ///< / remarks>
+  ///<param name="value">The file path, value or string to match.</param>
+  ///<param name="pattern">The pattern containing wildcards.</param>
+  ///<param name="captures">The captured value of wildcard within the input value. The number of captures matches the number of wildcard in the pattern.</param>
+  ///<returns>Returns true if the value matches the pattern, otherwise false.</returns>
+  bool wildcard_match(const std::string& value, const std::string& pattern, std::vector<std::string>& captures);
+
+  ///<summary>
+  ///Checks if a given value matches a pattern containing wildcard characters definition.
+  ///</summary>
+  ///<remarks>
+  ///  Supported Wildcards :
+  ///  -'?' matches any single character.
+  ///  -'*' matches zero or more characters.
+  ///  -'#' matches any single digit(0 - 9).
+  ///  -'[charlist]' matches any character in the provided set.
+  ///  -'[a-z]', '[A-Z]', '[0-9]' match characters in respective ranges.
+  ///  -'[a-zA-Z0-9]' matches any alphanumeric character.
+  ///< / remarks>
+  ///<param name="value">The file path, value or string to match.</param>
+  ///<param name="pattern">The pattern containing wildcards.</param>
+  ///<returns>Returns true if the value matches the pattern, otherwise false.</returns>
+  inline bool wildcard_match(const std::string& value, const std::string& pattern)
+  {
+    std::vector<std::string> tmp_captures;
+    return wildcard_match(value, pattern, tmp_captures);
+  }
+
+}; //bin2cpp
+
+#endif //BIN2CPP_COMMON_H
diff --git a/test/bin2cpp_unittest/CMakeLists.txt b/test/bin2cpp_unittest/CMakeLists.txt
@@ -228,13 +228,20 @@ add_custom_target(build_test_files ALL
 
 # Show all generated files in a common folder
 source_group("Generated Files" FILES ${GENERATED_TEST_FILES})
-source_group("External Files" FILES ${CMAKE_SOURCE_DIR}/src/bin2cpp/common.cpp ${CMAKE_SOURCE_DIR}/src/bin2cpp/common.h)
+source_group("External Files" FILES 
+  ${CMAKE_SOURCE_DIR}/src/bin2cpp/common.cpp
+  ${CMAKE_SOURCE_DIR}/src/bin2cpp/common.h
+  ${CMAKE_SOURCE_DIR}/src/bin2cpp/wildcard.cpp
+  ${CMAKE_SOURCE_DIR}/src/bin2cpp/wildcard.h
+)
 
 add_executable(bin2cpp_unittest
   ${BIN2CPP_VERSION_HEADER}
   ${BIN2CPP_CONFIG_HEADER}
   ${CMAKE_SOURCE_DIR}/src/bin2cpp/common.cpp
   ${CMAKE_SOURCE_DIR}/src/bin2cpp/common.h
+  ${CMAKE_SOURCE_DIR}/src/bin2cpp/wildcard.cpp
+  ${CMAKE_SOURCE_DIR}/src/bin2cpp/wildcard.h
   application.cpp
   application.h
   CMakeLists.txt
@@ -248,6 +255,8 @@ add_executable(bin2cpp_unittest
   TestCommon.h
   TestExtraction.cpp
   TestExtraction.h
+  TestWildcard.cpp
+  TestWildcard.h
   ${GENERATED_TEST_FILES}
 )
 
diff --git a/test/bin2cpp_unittest/TestWildcard.cpp b/test/bin2cpp_unittest/TestWildcard.cpp
@@ -0,0 +1,114 @@
+/**********************************************************************************
+ * MIT License
+ * 
+ * Copyright (c) 2018 Antoine Beauchamp
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *********************************************************************************/
+
+#include "TestWildcard.h"
+
+#include "wildcard.h"
+
+void TestWildcard::SetUp()
+{
+}
+
+void TestWildcard::TearDown()
+{
+}
+
+std::string to_boolean_str(bool value)
+{
+  return (value ? "true" : "false");
+}
+
+TEST_F(TestWildcard, testBasicExamples)
+{
+  struct TESTVALUE
+  {
+    const char* value;
+    const char* pattern;
+    bool expected_result;
+    std::vector<std::string> expected_captures;
+  };
+  static const TESTVALUE test_values[] = {
+      // ============================== matches ==============================
+      // ?
+      {"a", "?",                                                      true, {"a"}},
+      {"abc", "???",                                                  true, {"a", "b", "c"}},
+      {"kernel32.dll", "kernel??.dll",                                true, {"3", "2"}},
+      {"kernel32.dll", "kernel32.???",                                true, {"d", "l", "l"}},
+      {"kernel32.dll", "???nel32.dll",                                true, {"k", "e", "r"}},
+
+      // *
+      {"kernel32.dll", "*",                                           true, {"kernel32.dll"}},
+      {"kernel32.dll", "ker*.dll",                                    true, {"nel32"}},
+      {"kernel32.dll", "kernel32.*",                                  true, {"dll"}},
+      {"kernel32.dll", "*.dll",                                       true, {"kernel32"}},
+
+      // empty '*' wildcard
+      {"kernel32.dll", "*kernel32.dll",                               true, {""}},
+      {"kernel32.dll", "kernel32*.dll",                               true, {""}},
+      {"kernel32.dll", "kernel32.dll*",                               true, {""}},
+
+      // #
+      {"kernel32.dll", "kernel##.dll",                                true, {"3", "2"}},
+
+      // [abc]
+      {"kernel32.dll", "[Kk]ernel32.dll",                             true, {"k"}},
+      {"kernel32.dll", "kernel32.[dD][lL][lL]",                       true, {"d", "l", "l"}},
+      {"kernel32.dll", "ke[r]nel32.dll",                              true, {"r"}},
+
+      // [ranges]
+      {"kernel32.dll", "kernel[0-9][0-9].dll",                        true, {"3", "2"}},
+      {"kernel32.dll", "kernel32.[a-zA-Z0-9][a-zA-Z0-9][a-zA-Z0-9]",  true, {"d", "l", "l"}},
+      
+      // complex, multiple wildcard
+      {"kernel32.dll", "ker*.*",                                      true, {"nel32", "dll"}},
+      {"kernel32.dll", "*##.???",                                     true, {"kernel", "3", "2", "d", "l", "l"}},
+      {"aabbccdd", "*??*dd",                                          true, {"", "a", "a", "bbcc"}},
+
+      // ============================== failing matches ==============================
+      {"kernel32.dll",  "ker*.txt",                                   false, {}},
+      
+      // too many '?' character
+      {"kernel32.dll", "kernel32?.dll",                               false, {}},
+      {"kernel32.dll", "kernel32.dll?",                               false, {}},
+      {"kernel32.dll", "?kernel32.dll",                               false, {}},
+
+      {"kernel32.dll",  "k##nel32.dll",                               false, {}},
+      {"kernel32.dll",  "[aA]ernel32.dll",                            false, {}},
+      {"kernel32.dll",  "k[0-9]ernel32.dll",                          false, {}},
+      {"!",  "[a-zA-Z0-9]",                                           false, {}},
+  };
+  static const size_t num_test_values = sizeof(test_values) / sizeof(test_values[0]);
+
+  for ( size_t i = 0; i < num_test_values; i++ )
+  {
+    const TESTVALUE& t = test_values[i];
+
+    std::vector<std::string> actual_captures;
+    bool actual_result = bin2cpp::wildcard_match(t.value, t.pattern, actual_captures);
+
+    ASSERT_EQ(actual_result, t.expected_result)     << "Test fail with test_values[" << i << "]. The match between value '" << t.value << "' and pattern '" << t.pattern << "' is supposed to return '" << to_boolean_str(t.expected_result) << "' but it actually retuned '" << to_boolean_str(actual_result) << "'.";
+    ASSERT_EQ(actual_captures, t.expected_captures) << "Test fail with test_values[" << i << "]. The match between value '" << t.value << "' and pattern '" << t.pattern << "' is has returned '" << to_boolean_str(t.expected_result) << "' but the expected captures does not match.";
+  }
+
+}
diff --git a/test/bin2cpp_unittest/TestWildcard.h b/test/bin2cpp_unittest/TestWildcard.h

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ add_executable(bin2cpp`
`28`	`28`	`SegmentGenerator.h`
`29`	`29`	`StringGenerator.cpp`
`30`	`30`	`StringGenerator.h`
	`31`	`+ wildcard.cpp`
	`32`	`+ wildcard.h`
`31`	`33`	`Win32ResourceGenerator.cpp`
`32`	`34`	`Win32ResourceGenerator.h`
`33`	`35`	`)`