Wildcard string compare (globbing)

public static class StringExtensions
{
    public static bool WildcardMatch(this string str, string compare, bool ignoreCase)
    {
        if (ignoreCase)
            return str.ToLower().WildcardMatch(compare.ToLower());
        else
            return str.WildcardMatch(compare);
    }

    public static bool WildcardMatch(this string str, string compare)
    {
        if (string.IsNullOrEmpty(compare))
            return str.Length == 0;
        int pS = 0;
        int pW = 0;
        int lS = str.Length;
        int lW = compare.Length;

        while (pS < lS && pW < lW && compare[pW] != '*')
        {
            char wild = compare[pW];
            if (wild != '?' && wild != str[pS])
                return false;
            pW++;
            pS++;
        }

        int pSm = 0;
        int pWm = 0;
        while (pS < lS && pW < lW)
        {
            char wild = compare[pW];
            if (wild == '*')
            {
                pW++;
                if (pW == lW)
                    return true;
                pWm = pW;
                pSm = pS + 1;
            }
            else if (wild == '?' || wild == str[pS])
            {
                pW++;
                pS++;
            }
            else
            {
                pW = pWm;
                pS = pSm;
                pSm++;
            }
        }
        while (pW < lW && compare[pW] == '*')
            pW++;
        return pW == lW && pS == lS;
    }
}

public class MString2
{
   /// <summary>
   /// Function to compare two strings, where strA may contain wildcard characters '*' and
   /// '?'. http://en.wikipedia.org/wiki/Wildcard_character
   /// </summary>
   /// <param name="strA">string which may contain wildcards, may be empty, must not be null</param>
   /// <param name="strB">string to compare to, no wildcard processing, may be empty, must not be null</param>
   /// <param name="ignoreCase">true = ignore upper/lower case, false = don't ignore case</param>
   /// <returns>true = match, false = non-match</returns>
   public static bool CompareWWc(string strA, string strB, bool ignoreCase)
   {
      if (ignoreCase)
         return CompareWWc(strA.ToLower(), 0, strB.ToLower(), 0);
      else
         return CompareWWc(strA, 0, strB, 0);
   }


   /// <summary>
   /// Function to compare two strings, where strA may contain wildcard characters '*' and
   /// '?'. http://en.wikipedia.org/wiki/Wildcard_character
   /// </summary>
   /// <param name="strA">string which may contain wildcards, may be empty, must not be null</param>
   /// <param name="strB">string to compare to, no wildcard processing, may be empty, must not be null</param>
   /// <returns>true = match, false = non-match</returns>
   public static bool CompareWWc(string strA, string strB)
   {
      // Just call the private recursive version of this function
      return CompareWWc(strA, 0, strB, 0);
   }


   /// <summary>
   /// Private recursive function used by the above two public functions.
   /// </summary>
   /// <param name="strA">string which may contain wildcards, may be empty, must not be null</param>
   /// <param name="indexA">index into strA marking start of the string for processing purposes</param>
   /// <param name="strB">string to compare to, no wildcard processing, may be empty, must not be null</param>
   /// <param name="indexB">index into strB marking start of the string for processing purposes</param>
   /// <returns>true = match, false = non-match</returns>
   private static bool CompareWWc(string strA, int indexA, string strB, int indexB)
   {
      // Top of loop to scan across strA (and strB)
      for (int i = 0; indexA + i < strA.Length; i++)
      {
         // Special processing when we hit a '*' in strA
         if (strA[indexA + i] == '*')
         {
            // If the '*' is at the end of strA then result = true irrespective of strB
            if (indexA + i == strA.Length - 1)
               return true;

            // Do recursive calls to try to find a match somewhere to the right in strB
            for (int j = indexB + i; j < strB.Length; j++)
               if (CompareWWc(strA, indexA + i + 1, strB, j))
                  return true;
            return false;
         }

         // Normal processing for non-'*' characters in strA
         if (indexB + i >= strB.Length || (strA[indexA + i] != strB[indexB + i] && strA[indexA + i] != '?'))
            return false;
      }

      // We've reached the end of strA and there is no '*' in strA
      return strA.Length - indexA == strB.Length - indexB;
   }

}

My original version:  342 nonoseconds
Your version:         237 nanoseconds
My second version:    279 nanoseconds

My original version:  243 nonoseconds
Your version:          76 nanoseconds
My second version:    111 nanoseconds

public class MString
{
   /// <summary>
   /// Compare two strings, where strA may contain wildcard characters '*' and '?'.
   /// </summary>
   /// <param name="strA">string which may contain wildcards, may be empty,
   ///                    must not be null</param>
   /// <param name="strB">string to compare to, no wildcard processing, may be empty,
   ///                    must not be null</param>
   /// <param name="ignoreCase">true = ignore upper/lower case, false = observe case</param>
   /// <returns>true = match, false = non-match</returns>
   public static bool CompareWWc(string strA, string strB, bool ignoreCase)
   {
      if (ignoreCase)
         return CompareWWc(strA.ToLower(), strB.ToLower());
      else
         return CompareWWc(strA, strB);
   }


   /// <summary>
   /// Compare two strings, where strA may contain wildcard characters '*' and '?'.
   ///
   /// In the comments, the word 'segment' is used to talk about the portions of strA that
   /// fall between two '*' characters, or between the start of the string and the first '*'
   /// or between the last '*' and the end of the string.
   /// </summary>
   /// <param name="strA">string which may contain wildcards, may be empty,
   ///                    must not be null</param>
   /// <param name="strB">string to compare to, no wildcard processing, may be empty,
   ///                    must not be null</param>
   /// <returns>true = match, false = non-match</returns>
   public static bool CompareWWc(string strA, string strB)
   {
      int starPtr = 0;  // Points at the '*' in strA

      // This part of the code handles the first segment in strA, or the case where strA
      //  does not contain any '*' character at all. The first segment is fairly simple to
      //  handle because it must match from the start of strB - no need to have a sliding
      //  match loop.

      // Check strB long enough so we don't need to test for hitting its end while scanning
      if (strB.Length >= strA.Length)
      {
         // Simple optimized scan of first segment of strA and comparison with strB
         for (;; starPtr++)
         {
            if (starPtr == strA.Length)
               return strA.Length == strB.Length;  // No '*' in strA and no mismatch
            if (strA[starPtr] == '*')
               goto firstSegmentMatches;
            if (strA[starPtr] != strB[starPtr] && strA[starPtr] != '?')
               return false;  // Mismatch
         }
      }
      else
      {
         // When strB is shorter than strA a match is not likely. But if strA contains
         //  enough '*' characters it is possible, so we have to give it a try.
         for (;; starPtr++)
         {
            if (strA[starPtr] == '*')
               goto firstSegmentMatches;
            if (starPtr == strB.Length)
               return false;  // No '*' in strA before end of strB encountered
            if (strA[starPtr] != strB[starPtr] && strA[starPtr] != '?')
               return false;  // Mismatch
         }
      }

      // The rest of the code handles the case where strA does contain one or more '*'
      //  characters, and the first segment does match the start of strB.

   firstSegmentMatches:

      int indexA;  // Start of segment in strA
      int indexB = starPtr;  // Sliding match location in strB

      // Loop to process the segments in strA
      while (true)
      {
         // Test if next segment is last and empty
         indexA = ++starPtr;  // Point past '*'
         if (indexA == strA.Length)
            return true;  // Last segment empty - matches irrespective of strB content

         // Scan over the next segment in strA
         for (;; starPtr++)
            if (starPtr == strA.Length || strA[starPtr] == '*')
               break;

         // Try to find match for this segment somewhere in strB
         for (;; indexB++)
         {
            if (starPtr - indexA > strB.Length - indexB)
               return false;  // Mismatch if not enough characters left in strB

            for (int i = indexA, j = indexB; i < starPtr; i++, j++)
               if (strA[i] != strB[j] && strA[i] != '?')
                  goto tryStringBAgain;

            goto findNextSegment;  // Match found for this segment in strB

         tryStringBAgain:
            continue;
         }

         // Was that last segment? Return if so, loop if not.
      findNextSegment:
         indexB += starPtr - indexA;  // Point past matching portion of strB
         if (starPtr == strA.Length)
            return indexB == strB.Length;  // Return if that was last segment
      }
   }

}

My original version:  243 nanoseconds    17 lines of code
Erwin's version:       76 nanoseconds    42 lines of code
My second version:    111 nanoseconds    16 lines of code
My third version:      56 nanoseconds    52 lines of code

bool StrWildCmp(char* wildstring, char *matchstring){
   char stopstring[1];
   *stopstring = '\0';

   while(*matchstring != '\0')
   {
      if (*wildstring == '*') 
      {
         do
         {         
            wildstring++;            
         } while (*wildstring == '*');  // if a dork entered two or more * in a row 
                                        // ignore them and go ahead
         
         if (*wildstring == '\0')   // if * was the last char, the strings are equal
         {
            return TRUE;
         }
         else
         {
            *stopstring = *wildstring; // the next char to check after the *
         }
      }

      if(*stopstring != '\0')
      {
         if((*stopstring == *matchstring) || (*stopstring == '?') ) 
         {
            wildstring++;
            *stopstring = '\0';
         }
         matchstring++;
      }
      else
         if((*wildstring == *matchstring) || (*wildstring == '?'))
         {
            wildstring++;
            matchstring++;
         }
         else
         {
            return FALSE;
         }

      if( (*matchstring == '\0') && (*wildstring != '\0') )
      {
         // matchstring seems to be too short. Check if wildstring has any more chars except '*'
         while (*wildstring == '*') // ignore following '*'
            wildstring++;
         
         if (*wildstring == '\0') // if wildstring endet after '*', strings are equal
            return TRUE;
         else
            return FALSE;
      }
}