Wildcard string compare (globbing)

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

int wildcmp(const wchar_t *wild, const wchar_t *string)
  {
  const wchar_t *cp = NULL, *mp = NULL;
 
  while ((*string) && (*wild != L'*')) {
    if ((towlower(*wild) != towlower(*string)) && (*wild != L'?')) {
      return 0;
    }
    wild++;
    string++;
  }
 
  while (*string) {
    if (*wild == L'*') {
      if (!*++wild) {
        return 1;
      }
      mp = wild;
      cp = string+1;
    } else if ((towlower(*wild) == towlower(*string)) || (*wild == L'?')) {
      wild++;
      string++;
    } else {
      wild = mp;
      string = cp++;
    }
  }
 
  while (*wild == L'*') {
    wild++;
  }
  return !*wild;
}

if (wildcmp(L"*bl?h.*", L"asblah.plm")) {
  //we have a match!
   MessageBox(0,"we have a match!","wildcmp wide",MB_TOPMOST);
} else {
  //no match =(
      MessageBox(0,"no match!","wildcmp wide",MB_TOPMOST);
}

public static bool WildcardMatch(string strCompare, string strWild, bool bIgnoreCase)
{
    if (bIgnoreCase)
    {
        strWild = strWild.ToUpper();
        strCompare = strCompare.ToUpper();
    }
 
    // Lengths of strings
    int iWildLen = strWild.Length;
    int iCompareLen = strCompare.Length;
 
    // Used to save position when '*' found in strWild
    // Initialized to invalid values
    int iWildMatched = iWildLen;
    int iCompareBase = iCompareLen;
 
    int iWild = 0;
    int iCompare = 0;
 
    // Match until first wildcard '*'
    while (iCompare < iCompareLen && (iWild >= iWildLen || strWild[iWild] != '*'))
    {
        if (iWild >= iWildLen || (strWild[iWild] != strCompare[iCompare] && strWild[iWild] != '?'))
            return false;
 
        iWild++;
        iCompare++;
    }
 
    // Process wildcard
    while (iCompare < iCompareLen)
    {
        if (iWild < iWildLen)
        {
            if (strWild[iWild] == '*')
            {
                iWild++;
 
                if (iWild == iWildLen)
                    return true;
 
                iWildMatched = iWild;
                iCompareBase = iCompare + 1;
 
                continue;
            }
 
            if (strWild[iWild] == strCompare[iCompare] || strWild[iWild] == '?')
            {
                iWild++;
                iCompare++;
 
                continue;
            }
        }
 
        iWild = iWildMatched;
        iCompare = iCompareBase++;
    }
 
    while (iWild < iWildLen && strWild[iWild] == '*')
        iWild++;
 
    if (iWild < iWildLen)
        return false;
 
    return true;
}