Wildcard string compare (globbing)

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

	private bool wildcmp(string wild, string str) 
	{
		int cp=0, mp=0;
	
		int i=0;
		int j=0;
		while ((i<str.Length) && (wild[j] != '*')) 
		{
			if ((wild[j] != str[i]) && (wild[j] != '?')) 
			{
				return false;
			}
			i++;
			j++;
		}
		
		while (i<str.Length) 
		{
			if (j<wild.Length && wild[j] == '*') 
			{
				if ((j++)>=wild.Length) 
				{
					return true;
				}
				mp = j;
				cp = i+1;
			} 
			else if (j<wild.Length && (wild[j] == str[i] || wild[j] == '?')) 
			{
				j++;
				i++;
			} 
			else 
			{
				j = mp;
				i = cp++;
			}
		}
		
		while (j<wild.Length && wild[j] == '*') 
		{
			j++;
		}
		return j>=wild.Length;
	}

    public static boolean matcher(String value, String pattern) {
        if (pattern == null || value == null) {
            return false;
        }
 
        char[] Wildcards = new char[]{'*', '?'};
 
        pattern = pattern.toLowerCase();
        value = value.toLowerCase();
 
        // if pattern doesn't actually contain any wildcards, use simple equality
        if (pattern.indexOf(Wildcards[0]) == -1 && pattern.indexOf(Wildcards[1]) == -1) {
            return value.equals(pattern);
        }
 
        // otherwise do pattern matching
        int i = 0;
        int j = 0;
        while (i < value.length() && j < pattern.length() && pattern.charAt(j) != '*') {
            if (pattern.charAt(j) != value.charAt(i) && pattern.charAt(j) != '?') {
                return false;
            }
            i++;
            j++;
        }
 
        // if we have reached the end of the pattern without finding a * wildcard,
        // the match must fail if the String is longer or shorter than the pattern
        if (j == pattern.length()) {
            return value.length() == pattern.length();
        }
 
        int cp = 0;
        int mp = 0;
        while (i < value.length()) {
            if (j < pattern.length() && pattern.charAt(j) == '*') {
                if ((j++) >= pattern.length()) {
                    return true;
                }
                mp = j;
                cp = i + 1;
            }
            else if (j < pattern.length() && (pattern.charAt(j) == value.charAt(i) || pattern.charAt(j) == '?')) {
                j++;
                i++;
            }
            else {
                j = mp;
                i = cp++;
            }
        }
 
        while (j < pattern.length() && pattern.charAt(j) == '*') {
            j++;
        }
 
        return j >= pattern.length();
    }

  public void testmatcher() {
        System.out.println("testmatcher");
 
        String[][] matchPaire = {
            {"", ""},
            {"aa", "aa"},
            {"aa", "*"}, //value,pattern
            {"a", "?"},
            {"sdwerporasl;df", "*"},
            {"absdf zzzy", "*zzy"},
            {"abc", "*?"}};
 
        String[][] notMatchPaire = {
            {"", "?"},
            {"ab", "?"},
            {null, null},
            {"", "*a"},
            {"bsadfasdfwer234", "a*"},
            {"a fwer234", "*a"},
            };
 
        for (int i = 0; i < matchPaire.length; i++) {
            System.out.print("paire " + matchPaire[i][0] + " " + matchPaire[i][1]);
            assertTrue(ExchUtils.matcher(matchPaire[i][0], matchPaire[i][1]));
            System.out.println(" ok");
        }
 
        for (int i = 0; i < notMatchPaire.length; i++) {
            System.out.print("paire " + notMatchPaire[i][0] + " " + notMatchPaire[i][1]);
            assertFalse(ExchUtils.matcher(notMatchPaire[i][0], notMatchPaire[i][1]));
            System.out.println(" ok");
        }
    }

int cp=0;
int mp=0;
while (i < s.Length)
{
  if (j < pattern.Length && pattern[j] == '*')
  {
    if ((j++)>=pattern.Length)
      return true;

if ((j++) >= pattern.Length) 
{
  return true;
}

if (++j >= pattern.Length)
{
 return true;
}