Wildcard string compare (globbing)

Usage:

This is a fast, lightweight, and simple pattern matching function.

if (wildcmp("bl?h.*", "blah.jpg")) {
  //we have a match!
} else {
  //no match =(
}

Function:

int wildcmp(const char *wild, const char *string) {
  // Written by Jack Handy - <A href="mailto:jakkhandy@hotmail.com">jakkhandy@hotmail.com</A>
  const char *cp = NULL, *mp = NULL;

  while ((*string) && (*wild != '*')) {
    if ((*wild != *string) && (*wild != '?')) {
      return 0;
    }
    wild++;
    string++;
  }

  while (*string) {
    if (*wild == '*') {
      if (!*++wild) {
        return 1;
      }
      mp = wild;
      cp = string+1;
    } else if ((*wild == *string) || (*wild == '?')) {
      wild++;
      string++;
    } else {
      wild = mp;
      string = cp++;
    }
  }

  while (*wild == '*') {
    wild++;
  }
  return !*wild;
}

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Jack Handy

Web Developer

United States

Member

No Biography provided

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board.

Search this forum
	Profile popups Spacing Noise Layout Per page

mp and cp

twopieman

15 Mar '05 - 11:59

i got the overall flow of the program I didnt get the logic of the second loop completely. I understand that in the second loop it checks if there is nothing after * if so then it is a match but if there is something it stores them in the two pointers and then goes on.
also in the final else it goes like else
{
wild = mp;
string = cp++;
}
am sorry but am not getting the logic totally.
can someone please explain?

Re: mp and cp

radboudp

16 Feb '07 - 1:14

In case you are matching something like the following:

"*.abc" to "ab.de.abc"

In the second loop it looks for the first character after the asterisk that is the same in the string. At first it matches "*" against "ab". mp = ".abc" during this. Now wild = ".abc" and string = ".de.abc". Obvious no match. On the next loop the first characters do match (both '.') and wild becomes "abc" and string "de.abc". The next loop there is no match and it falls to the else. Here it resets wild to the last mp (mask pattern??) and string to the last cp (character pattern) WITHOUT THE FIRST CHARACTER. (It actually advances cp one position.)

Why does it do this. After matching the * against part of the string and encountering a possible poisiton where to match the remainder of the pattern, it continued comparing characters from both to each other. This fialed. Since right before the position of mp there was a *, it is still allowed to add characters to the part that is matched against that. Basically, it goes back to that position but decides that the character that occurs in both strings is not the next character in the pattern but part of the '*' wildcard.

In the end it has matched '*' with 'ab.de'.

OK, but ...

Sam Levy

16 Feb '05 - 4:48

what was changed?
Sign In·View Thread·Permalink

Why make 3 loop ?

DarkYoda Mickael

2 Feb '05 - 22:22

Hello, i think this post is very interesting because is very simple and make very cool work ! BUT ! I don't understand why you make 3 loop to do it ? I think i don't see all case, because for me only the 2 loop make all the work ? I'm trying to understand all the process to add optionnal char with the ^ escape sequence, for exemple : ^-* match -12 or 12 Thanks
Sign In·View Thread·Permalink

Re: Why make 3 loop ?

Jack Handy

13 Feb '05 - 10:02

DarkYoda Mickael wrote:
I don't understand why you make 3 loop to do it ?

I think i don't see all case, because for me only the 2 loop make all the work ?

The third loop:

while (*wild == '*') {

    wild++;

}

is there to take care of trailing *'s. Since * means 0 or more chars, "test*" should match "test" just fine. That loop takes care of this case.

-Jack

There are 10 types of people in this world, those that understand binary and those who don't.

C# version

Sancy

26 Oct '04 - 6:23

Hi, i have a stupid question, could someone give me the c# version thanks in advance
Sign In·View Thread·Permalink

Re: C# version

Psyk66

21 Dec '04 - 3:39

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

This C# version works. I'm sure there are loads of improvements to be made though. Don't flame me for such bad code, I only started C# yesterday;)

Re: C# version

Ionut FIlip

22 Feb '05 - 6:15

A small fix: while ((i<str.Length) && (wild[j] != '')) should be while (i < str.Length && j < wild.Length && wild[j] != '') And a small improvement for case sensitivity: private bool wildcmp(string wild, string str, bool case_sensitive) { if (! case_sensitive) { wild = wild.ToLower(); str = str.ToLower(); } // rest of the code is the same } Ionut Filip
Sign In·View Thread·Permalink

Re: C# version

robagar

3 Apr '06 - 16:58

hiya

Just thought I'd share my version of this code

- put the whole shebang into a class with public static methods
- fixed a bug where the pattern '?' matches all strings
- added an early-exit test for patterns that don't actually contain wildcards so it just defaults to normal string comparison

cheers
Rob

     /// <summary>
     /// Class providing wildcard string matching.
     /// </summary>
     public class Wildcard
     {
          private Wildcard()
          {
          }

          /// <summary>
          /// Array of valid wildcards
          /// </summary>
          private static char[] Wildcards = new char[]{'*', '?'};

          /// <summary>
          /// Returns true if the string matches the pattern which may contain * and ? wildcards.
          /// Matching is done without regard to case.
          /// </summary>
          /// <param name="pattern"></param>
          /// <param name="s"></param>
          /// <returns></returns>
          public static bool Match(string pattern, string s)
          {
               return Match(pattern, s, false);
          }

          /// <summary>
          /// Returns true if the string matches the pattern which may contain * and ? wildcards.
          /// </summary>
          /// <param name="pattern"></param>
          /// <param name="s"></param>
          /// <param name="caseSensitive"></param>
          /// <returns></returns>
          public static bool Match(string pattern, string s, bool caseSensitive)
          {
               // if not concerned about case, convert both string and pattern
               // to lower case for comparison
               if (!caseSensitive)
               {
                    pattern = pattern.ToLower();
                    s = s.ToLower();
               }

               // if pattern doesn't actually contain any wildcards, use simple equality
               if (pattern.IndexOfAny(Wildcards) == -1)
                    return (s == pattern);

               // otherwise do pattern matching
               int i=0;
               int j=0;
               while (i < s.Length && j < pattern.Length && pattern[j] != '*')
               {
                    if ((pattern[j] != s[i]) && (pattern[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 s.Length == pattern.Length;

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

               while (j < pattern.Length && pattern[j] == '*')
               {
                    j++;
               }

               return j >= pattern.Length;
          }
     }

Re: C# version

Sancy

5 Jun '06 - 16:01