Partially reverted 17b6225 back to a98b66d (with some variations)

Author: end2endzone

src/Wildcard.cpp

@@ -29,7 +29,24 @@
 
 namespace shellanything
 {
-  typedef std::vector<WildcardResult> WildcardResultList;
+  static const size_t INVALID_WILDCARD_POSITION = (size_t)-1;
+
+  size_t GetNextWildcardPosition(const size_t * wildcard_positions, size_t num_wildcards, size_t current)
+  {
+    for(size_t i=0; i<num_wildcards; i++)
+    {
+      const size_t & pos = wildcard_positions[i];
+      if (pos == current)
+      {
+        if (i+1 < num_wildcards)
+        {
+          return wildcard_positions[i+1];
+        }
+        return INVALID_WILDCARD_POSITION; //requested wildcard is the last one
+      }
+    }
+    return INVALID_WILDCARD_POSITION; //wildcard position not found
+  }
 
   bool IsWildcard(char c)
   {
@@ -136,224 +153,178 @@ namespace shellanything
     return true;
   }
 
-  bool WildcardSolve(const char * pattern, const char * value, WildcardResultList * presults)
+  bool WildcardSolve( const char * pattern,
+                      const char * value,
+                      const size_t * wildcard_positions,
+                      size_t num_wildcards,
+                      const int iIndexWild,
+                      const int iIndexValue,
+                      WildcardList & matches)
   {
-    size_t pattern_length = strlen(pattern);
-    size_t value_length = strlen(value);
-
-    // If the pattern is empty, the value must also be empty to match.
-    if (pattern_length == 0)
+    int indexWild = iIndexWild;
+    int indexValue = iIndexValue;
+    int wildLen   = (int)std::string(pattern).size();
+    int valueLen  = (int)std::string(value).size();
+  
+    //while wildcard and value not fully solved
+    while (indexWild < wildLen || indexValue < valueLen)
     {
-      // If not, then there is not match.
-      if (value_length == 0)
+      const char & cWild  = pattern[indexWild];
+      const char & cValue = value[indexValue];
+      if ( !IsWildcard(cWild) )
       {
-        //if (presults)
-        //{
-        //  WildcardResult r = {0};
-        //  r.valid = true;
-        //  r.pattern_offset = 0;
-        //  r.value = value;
-        //  r.value_length = 0;
-        //  presults->push_back(r);
-        //}
-        return true;
-      }
-      return false;
-    }
+        if (cWild != cValue)
+          return false; //characters don't match!
 
-    // If the value is empty, the pattern must be '*' (or a '*' sequence) to match
-    if (value_length == 0)
-    {
-      if (!IsStarSequence(&pattern[0]))
-        return false;
-
-      // We have a match.
-      if (presults)
-      {
-        WildcardResult r = {0};
-        r.valid = true;
-        r.pattern_offset = 0;
-        r.value = value;
-        r.value_length = 0;
-        presults->push_back(r);
+        //next char
+        indexWild++;
+        indexValue++;
       }
-      
-      return true;
-    }
-
-    // At this point, both pattern and value are not empty
-
-    size_t value_offset = 0;
-    for(size_t pattern_offset = 0; pattern_offset < pattern_length; pattern_offset++)
-    {
-      const char & pattern_char = pattern[pattern_offset];
-      const char & value_char = value[value_offset];
-
-      // If we reached a '*' sequence, move forward to the last '*' character of the sequence
-      while(pattern[pattern_offset] == '*' && (pattern_offset+1 < pattern_length) && pattern[pattern_offset+1] == '*')
+      else
       {
-        pattern_offset++;
-      }
-
-      size_t remaining_pattern_length = pattern_length - pattern_offset;
-      size_t remaining_value_length = value_length - value_offset;
+        //cWild is wildcard
+        if (cWild == '?')
+        {
+          //save wildcard resolve information
+          WILDCARD w;
+          w.character = cWild;
+          w.index = indexWild;
+          w.value = cValue;
+          matches.push_back(w);
+
+          //next char
+          indexWild++;
+          indexValue++;
+        }
+        else if (cWild == '*')
+        {
+          //if wildcard character * is the last one
+          if (indexWild+1 >= wildLen)
+          {
+            //automatically match the end of the string
 
-      // If we reached the end of both strings, we are done searching
-      if (remaining_pattern_length == 0 && remaining_value_length == 0)
-        return true;
+            //save wildcard resolve information
+            WILDCARD w;
+            w.character = cWild;
+            w.index = indexWild;
+            w.value = &cValue;
+            matches.push_back(w);
 
-      // If the pattern is '*', and the next pattern character is valid, and the value is empty, then we won't be able to match.
-      // (because there is a next non-wildcard character in the pattern)
-      if (pattern_char == '*' &&
-        (pattern_offset+1 < pattern_length) &&  // pattern has more characters
-        pattern[pattern_offset+1] != '\0' &&    // next pattern character is valid)
-        remaining_value_length == 0)            // value is empty
-      {
-        return false;
-      }
+            // If we reached a '*' sequence, move forward to the last '*' character of the sequence
+            while(pattern[indexWild] == '*' && (indexWild+1 < wildLen) && pattern[indexWild+1] == '*')
+            {
+              indexWild++;
+            }
 
-      if (pattern_char == '?')
-      {
-        // In order to match, the '?' must match the current value character
-        if (value_char == '\0')
-          return false; // We reached the end of the value string
+            //next char
+            indexWild++;
+            indexValue += (int)w.value.size();
+          }
+          else
+          {
+            //wildcard character * is not the last one
 
-        // We matched this wildcard character
-        // Save this wildcard expansion
-        if (presults)
-        {
-          WildcardResult r = {0};
-          r.valid = true;
-          r.pattern_offset = pattern_offset;
-          r.value = &value[value_offset];
-          r.value_length = 1;
-          presults->push_back(r);
-        }
+            //compute all possibilities that can fit in * and then use recursion to check if it can be resolved
+            //compute the possibilities in the from the longest to the shortest ("") for optimizing the replacement string
+            //since all wildcard caracters must be mapped, do not compute possibilities beyond the next wildcard character
 
-        // Advance both offsets and keep on looking
-        value_offset++;
-      }
-      else if (pattern_char == value_char)
-      {
-        // Advance both offsets and keep on looking
-        value_offset++;
-      }
-      else if (pattern_char == '*')
-      {
-        // Found a '*' character or sequence.
-        // From this point, there are 2 possibilities.
+            //compute next character
+            const char & nextWild = (&cWild)[1];
 
-        WildcardResultList tmp;
-        WildcardResultList * sub_results = NULL;
-        if (presults)
-          sub_results = &tmp;
+            int nextWildcardPosition = (int)GetNextWildcardPosition(wildcard_positions, num_wildcards, indexWild);
 
-        // 1) The '*' replaces the next value character.
-        bool match = WildcardSolve(&pattern[pattern_offset], &value[value_offset+1], sub_results);
-        if (match)
-        {
-          // Add the sub results to our results
-          if (presults)
-          {
-            for(size_t i=0; i<sub_results->size(); i++)
+            //compute fixed characters between this wildcard and the last one (of the end of the file)
+            //ie: fgh in abc*fgh?j or abc*fgh
+            std::string fixedCharacters = &nextWild;
+            if (nextWildcardPosition != -1)
             {
-              WildcardResult & r = (*sub_results)[i];
-              r.pattern_offset += pattern_offset;
-              presults->push_back(r);
+              //there is at least another wildcard character after this one
+              fixedCharacters = &nextWild;
+              size_t size = nextWildcardPosition - indexWild;
+              fixedCharacters.resize(size);
             }
-            sub_results->clear();
-          }
 
-          return true;
-        }
+            //compute maximum length of replacementString
+            int remainingCharactersInValue = valueLen-indexValue;
+            int replacementStringMaxLength = remainingCharactersInValue-(int)fixedCharacters.size();
 
-        // 2) The '*' does not replaces the next value character.
-        match = WildcardSolve(&pattern[pattern_offset+1], &value[value_offset], sub_results);
-        if (match)
-        {
-          // Add the sub results to our results
-          if (presults)
-          {
-            for(size_t i=0; i<sub_results->size(); i++)
+            //compute all possibilities that can fit in * with a length in [0,replacementStringMaxLength]
+            for(int length=replacementStringMaxLength; length>=0; length--)
             {
-              WildcardResult & r = (*sub_results)[i];
-              r.pattern_offset += pattern_offset+1;
-              presults->push_back(r);
+              //assuming replacement string is the right one
+
+              std::string replacementString = &cValue;
+              replacementString.resize(length);
+
+              WildcardList tmpList = matches;
+
+              //save wildcard resolve information
+              WILDCARD w;
+              w.character = cWild;
+              w.index = indexWild;
+              w.value = replacementString;
+              tmpList.push_back(w);
+
+              //next char
+              int tmpIndexWild = indexWild+1;
+              int tmpIndexValue = indexValue + (int)w.value.size();
+
+              //execute recursive call
+              bool solved = WildcardSolve(pattern, value, wildcard_positions, num_wildcards, tmpIndexWild, tmpIndexValue, tmpList);
+              if (solved)
+              {
+                //solved!
+                //refresh matches
+                matches = tmpList;
+                return true;
+              }
             }
-            sub_results->clear();
-          }
 
-          return true;
+            //all possibilities were checked
+            //unable to solve * wildcard
+            return false;
+          }
         }
-
-        // We recurse on all possibilities. No match found.
-        return false;
-      }
-      else
-      {
-        // Characters from pattern and value does not match
-        return false;
       }
     }
 
-    // We reached the end of the pattern, the value must be empty too to match
-    if (value[value_offset] != '\0')
-      return false;
-
-    //// The remaining of the value is the expansion of the last wildcard character
-    //if (presults)
-    //{
-    //  WildcardResult r = {0};
-    //  r.valid = true;
-    //  r.pattern_offset = 0;
-    //  r.value = value;
-    //  r.value_length = 0;
-    //  presults->push_back(r);
-    //}
-
-    return true;
+    if (indexWild == wildLen && indexValue == valueLen)
+      return true; //solved
+    if ((indexWild == wildLen && indexValue < valueLen) ||
+        (indexWild == wildLen && indexValue < valueLen)     )
+      return false; //reached the end of wildcard or the end of value
+    return false; //???
   }
 
-  bool WildcardSolve(const char * pattern, const char * value, WildcardResult * results_array, size_t results_size)
+  bool WildcardSolve(const char * pattern, const char * value, WildcardList & matches)
   {
-    size_t results_array_count = results_size / sizeof(WildcardResult);
-    bool has_array = (results_array != NULL && results_array_count > 0);
-    if (has_array)
-      memset(results_array, 0, results_size);
-
     if (pattern == NULL || value == NULL)
       return false;
 
+    matches.clear();
+
     // Force the pattern to its simplest form
     std::string simplified_pattern = pattern;
     WildcardSimplify(simplified_pattern);
 
-    // Create a results list if required
-    WildcardResultList results;
-    WildcardResultList * presults = NULL;
-    if (has_array)
-      presults = &results;
+    // Find all wildcard character positions
+    size_t num_wildcards = FindWildcardCharacters(simplified_pattern.c_str(), NULL, 0);
+    
+    // If no wildcard character found, the strings must be equal
+    if (num_wildcards == 0)
+      return (std::string(pattern) == std::string(value));
 
-    // Search for a possible match
-    bool match = WildcardSolve(simplified_pattern.c_str(), value, presults);
-    if (!match)
-      return false;
+    // Allocate memory for all wildcard positions
+    size_t * wildcard_positions = new size_t[num_wildcards];
+    FindWildcardCharacters(simplified_pattern.c_str(), wildcard_positions, num_wildcards);
 
-    if (has_array)
-    {
-      // The pattern and value matches
-      // Copy the results list into results_array
-      #define MIN(a,b) ((a) < (b) ? (a) : (b))
-      size_t count = MIN(results.size(), results_array_count);
-      #undef MIN
-      for(size_t i=0; i<count; i++)
-      {
-        const WildcardResult & result = results[i];
-        results_array[i] = result;
-      }
-    }
+    //solve wildcards
+    bool solved = WildcardSolve(simplified_pattern.c_str(), value, wildcard_positions, num_wildcards, 0, 0, matches);
 
-    return true;
+    delete[] wildcard_positions;
+    wildcard_positions = NULL;
+
+    return solved;
   }
 
 } //namespace shellanything