The function WildcardMatch() have a new algorithm which is much faster and simpler to understand.

Modified unit tests to test both `WildcardSolve()` and `WildcardMatch()`.
Completed Wildcard.h functions for issue #58.

Author: end2endzone

src/Wildcard.cpp

@@ -48,13 +48,6 @@ namespace shellanything
     return INVALID_WILDCARD_POSITION; //wildcard position not found
   }
 
-  bool IsWildcard(char c)
-  {
-    if (c == '*' || c == '?')
-      return true;
-    return false;
-  }
-
   size_t FindWildcardCharacters(const char * str, size_t * offsets, size_t offsets_size)
   {
     // Validate str
@@ -326,4 +319,80 @@ namespace shellanything
     return solved;
   }
 
+  bool WildcardMatch(const char * pattern, const char * value)
+  {
+    if (pattern == NULL || value == NULL)
+      return false;
+
+    // Move forward in the pattern and the value as long as we have matching characters.
+    bool matching_characters = true;
+    while(matching_characters)
+    {
+      // If the pattern is empty, the value must also be empty to match.
+      if (pattern[0] == '\0')
+      {
+        if (value[0] == '\0')
+          return true;
+        return false;
+      }
+
+      // If the value is empty, the pattern must be '*' (or a '*' sequence) to match
+      if (value[0] == '\0')
+      {
+        if (!IsStarSequence(&pattern[0]))
+          return false;
+
+        // We have a match.
+        return true;
+      }
+
+      // At this point, both the pattern and the value are not empty.
+      // Both can be moved forward if we have a match.
+
+      // Now check if we have a matching characters
+      matching_characters = false;
+
+      // If we reached a '*' sequence, move forward in the pattern to the last '*' character of the sequence
+      while(pattern[0] == '*' && pattern[1] == '*')
+      {
+        pattern++;
+
+        // Even if did not had 'matching characters', set the flag to true so that we run another loop.
+        // This will allows us to check for special cases like:
+        // 1) pattern="" and value=""
+        // 2) pattern="*" and value=""
+        matching_characters = true;
+      }
+
+      // If the pattern contains '?', if both pattern and value characters are equals, move forward
+      if (pattern[0] == '?' || pattern[0] == value[0])
+      {
+        pattern++;
+        value++;
+
+        matching_characters = true;
+      }
+    }
+  
+    // If we reached a '*' character in the pattern, there is two possibilities:
+    // 1) The '*' replaces the next value character.
+    // 2) The '*' does not replaces the next value character.
+    // Use recursion to resolve the two possibilities.
+    if (pattern[0] == '*')
+    {
+      // 1) The '*' replaces the next value character.
+      bool match = WildcardMatch(pattern, value+1);
+      if (match)
+        return true;
+
+      // 2) The '*' does not replaces the next value character.
+      match = WildcardMatch(pattern+1, value);
+      if (match)
+        return true;
+    }
+
+    // No match possible
+    return false;
+  }
+
 } //namespace shellanything

src/Wildcard.h

@@ -47,19 +47,17 @@ namespace shellanything
   /// </summary>
   typedef std::vector<WILDCARD> WildcardList;
 
-  //struct WILDCARD_GROUP
-  //{
-  //  char character;
-  //  IntList indexes;
-  //};
-  //typedef std::vector<WILDCARD_GROUP> WildcardGroupList;
-
   /// <summary>
   /// Evaluates if the given character is a wildcard character supported by the library.
   /// </summary>
   /// <param name="c">The character to evaluate.</param>
   /// <returns>Returns true if the given character is a wildcard character. Returns false otherwise.</returns>
-  bool IsWildcard(char c);
+  inline bool IsWildcard(char c)
+  {
+    if (c == '*' || c == '?')
+      return true;
+    return false;
+  }
 
   /// <summary>
   /// Simplify a wildcard pattern. Remove sequences of '*' characters.
@@ -86,6 +84,8 @@ namespace shellanything
 
   /// <summary>
   /// Returns true if the given pattern with wildcard characters can be expanded to match the given value.
+  /// The function also returns the expanded value for each wildcard character match.
+  /// If you do not need to know the value of the wildcard characters, use the function <see cref="WildcardMatch()"/> which is faster.
   /// </summary>
   /// <param name="pattern">The string with the wildcard pattern.</param>
   /// <param name="value">The value to match.</param>
@@ -94,12 +94,13 @@ namespace shellanything
   bool WildcardSolve(const char * pattern, const char * value, WildcardList & matches);
 
   /// <summary>
-  /// RReturns true if the given pattern with wildcard characters can be expanded to match the given value.
+  /// Returns true if the given pattern with wildcard characters matches the given value.
+  /// If you need to know the value of the wildcard characters, use the function <see cref="WildcardSolve()"/>.
   /// </summary>
   /// <param name="pattern">The string with the wildcard pattern.</param>
   /// <param name="value">The value to match.</param>
-  /// <returns>Returns true if the given pattern with wildcard characters can be expanded to match the given value. Returns false otherwise.</returns>
-  inline bool WildcardMatch(const char * pattern, const char * value) { WildcardList tmp; return WildcardSolve(pattern, value, tmp); }
+  /// <returns>Returns true if the given pattern with wildcard characters matches the given value. Returns false otherwise.</returns>
+  bool WildcardMatch(const char * pattern, const char * value);
 
 } //namespace shellanything