Wildcard string compare (globbing)

   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;
      }
}