wild_match.c File Reference

Wildcard matching and string utility functions. More...

#include <ctype.h>
#include "mdb.h"

Go to the source code of this file.

Macros
#define	MATCH_INVERT   '^'
#define	MATCH_MANY   '*'
#define	MATCH_SET1   '['
#define	MATCH_SET2   ']'
#define	ESCAPE_CHAR   '\\'
#define	SET_MATCH_INVERT   '^'
#define	MATCH_ONE   '?'

Functions
int	wild_match (char *string, char *template)
	Determine whether one string is a wildcard match for another.
int	wild_match_ci (char *string, char *template)
	Determine whether one string is a case-insensitive wildcard match for another.
int	strcmp_ci (const char *s, const char *t)
	Compare two strings case-insensitively.
char *	strchr_ci (char *s, char c)
char *	expand_ranges (char *template)
	Expand range specifiers in a wildcard template into explicit character lists.
int	has_wildcards (char *template)
	Check if a template string contains any wildcard characters.
char *	unescape_wildcards (char *template)
	Remove escape characters from wildcard characters in a template string.
int	strcmp_nh (const char *s1, const char *s2)
	Compare two strings with a custom non-hierarchical ranking.

Detailed Description

Wildcard matching and string utility functions.

This file provides functions to perform wildcard pattern matching, expand range specifiers within templates, check for the presence of wildcard characters, and manipulate strings with respect to wildcard handling.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

M. Borland, C Saunders, R. Soliday, H. Shang

Definition in file wild_match.c.

Macro Definition Documentation

ESCAPE_CHAR

#define ESCAPE_CHAR   '\\'

Definition at line 29 of file wild_match.c.

MATCH_INVERT

#define MATCH_INVERT   '^'

Definition at line 25 of file wild_match.c.

MATCH_MANY

#define MATCH_MANY   '*'

Definition at line 26 of file wild_match.c.

MATCH_ONE

#define MATCH_ONE   '?'

Definition at line 35 of file wild_match.c.

MATCH_SET1

#define MATCH_SET1   '['

Definition at line 27 of file wild_match.c.

MATCH_SET2

#define MATCH_SET2   ']'

Definition at line 28 of file wild_match.c.

SET_MATCH_INVERT

#define SET_MATCH_INVERT   '^'

Definition at line 30 of file wild_match.c.

Function Documentation

expand_ranges()

char * expand_ranges

(

char *

template

)

Expand range specifiers in a wildcard template into explicit character lists.

Processes a wildcard template containing range specifiers (e.g., [a-e0-5]) and expands them into explicit lists of characters (e.g., [abcde012345]). This function should be called before performing wildcard matching with wild_match().

Parameters

template

The wildcard template containing range specifiers.

Returns

A newly allocated string with all range specifiers expanded into explicit lists.

Definition at line 429 of file wild_match.c.

                                    {
  char *new, *ptr, *ptr1, *ptr2, *end_new;
  int n_in_range;
 
  end_new = new = tmalloc(sizeof(*new) * (strlen(template) + 1));
  *new = 0;
  ptr = tmalloc(sizeof(*new) * (strlen(template) + 1));
  strcpy(ptr, template);
  while (*ptr) {
    if (*ptr == ESCAPE_CHAR) {
      *end_new++ = *ptr++;
      if (*ptr)
        *end_new++ = *ptr++;
      *end_new = 0;
    } else if (*ptr == MATCH_SET1) {
      *end_new++ = *ptr++;
      if ((ptr1 = strchr(ptr, MATCH_SET2))) {
        *ptr1 = 0;
        ptr2 = ptr;
        while (*ptr2) {
          *end_new++ = *ptr2++;
          *end_new = 0;
          if (*ptr2 == '-') {
            if (*(ptr2 - 1) == ESCAPE_CHAR) {
              *(end_new - 1) = '-';
              *end_new = 0;
              ptr2++;
            } else {
              ptr2++;
              n_in_range = (*ptr2) - (*(ptr2 - 2));
              if (n_in_range <= 0) {
                fprintf(stderr, "error: bad range syntax: %s\n", ptr - 2);
                exit(1);
              }
              new = trealloc(new, sizeof(*new) * (strlen(new) + n_in_range + strlen(ptr1 + 1) + 2));
              end_new = new + strlen(new);
              while (n_in_range--)
                *end_new++ = *ptr2 - n_in_range;
              *end_new = 0;
              ptr2++;
            }
          }
        }
        *end_new++ = *ptr1 = MATCH_SET2;
        *end_new = 0;
        ptr = ptr1 + 1;
      } else {
        *end_new++ = *(ptr - 1);
        *end_new = 0;
      }
    } else {
      *end_new++ = *ptr++;
      *end_new = 0;
    }
  }
  *end_new = 0;
  return (new);
}

has_wildcards()

int has_wildcards

(

char *

template

)

Check if a template string contains any wildcard characters.

Scans the input template string to determine if it includes any wildcard characters such as '*', '?', or character sets defined within brackets. Escaped wildcard characters (preceded by a backslash) are ignored.

Parameters

template

The string to check for wildcard characters.

Returns

Returns 1 if any unescaped wildcard characters are found, 0 otherwise.

Definition at line 498 of file wild_match.c.

                                  {
  char *ptr;
 
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_MANY))) {
    if (ptr == template || *(ptr - 1) != ESCAPE_CHAR)
      return (1);
    ptr++;
  }
 
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_ONE))) {
    if (ptr == template || *(ptr - 1) != ESCAPE_CHAR)
      return (1);
    ptr++;
  }
 
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_SET1))) {
    if (ptr == template || *(ptr - 1) != ESCAPE_CHAR)
      return (1);
    ptr++;
  }
 
  return (0);
}

strchr_ci()

char * strchr_ci	(	char *	s,
		char	c )

Definition at line 409 of file wild_match.c.

                                 {
  c = tolower(c);
  while (*s) {
    if (tolower(*s) == c)
      return s;
    s++;
  }
  return NULL;
}

strcmp_ci()

int strcmp_ci	(	const char *	s,
		const char *	t )

Compare two strings case-insensitively.

Performs a case-insensitive comparison between two strings. Returns 0 if the strings are equal, a negative value if the first non-matching character in s1 is lower than that in s2, and a positive value if it is greater.

Parameters

s	The first string to compare.
t	The second string to compare.

Returns

An integer indicating the relationship between the strings: -1 if s1 < s2, 0 if s1 == s2, 1 if s1 > s2.

Definition at line 396 of file wild_match.c.

                                            {
  char sc, tc;
  while (*s && *t) {
    if ((sc = tolower(*s)) < (tc = tolower(*t)))
      return -1;
    if (sc > tc)
      return 1;
    s++;
    t++;
  }
  return 0;
}

strcmp_nh()

int strcmp_nh	(	const char *	s1,
		const char *	s2 )

Compare two strings with a custom non-hierarchical ranking.

Compares two strings where non-numeric characters are ranked before numeric characters. Numeric characters are compared based on their length, with single-digit numbers ranked before multi-digit numbers. The comparison returns -1, 0, or 1 depending on whether the first string is less than, equal to, or greater than the second string.

Parameters

s1	The first string to compare.
s2	The second string to compare.

Returns

An integer indicating the relationship between the strings: -1 if s1 < s2, 0 if s1 == s2, 1 if s1 > s2.

Definition at line 583 of file wild_match.c.

                                              {
  int n1, n2, n3, n4;
  int i;
  for (; *s1 && *s2; s1++, s2++) {
    if (((*s1 >= '0') && (*s1 <= '9')))
      n1 = 1;
    else
      n1 = 0;
    if (((*s2 >= '0') && (*s2 <= '9')))
      n2 = 1;
    else
      n2 = 0;
    if ((n1 == 1) && (n2 == 1)) {
      i = 1;
      while ((*(s1 + i)) && (*(s2 + i))) {
        if (((*(s1 + i) >= '0') && (*(s1 + i) <= '9')))
          n3 = 1;
        else
          n3 = 0;
        if (((*(s2 + i) >= '0') && (*(s2 + i) <= '9')))
          n4 = 1;
        else
          n4 = 0;
        if ((n3 == 1) && (n4 == 0))
          return (1);
        else if ((n3 == 0) && (n4 == 1))
          return (-1);
        else if ((n3 == 0) && (n4 == 0))
          break;
        i++;
      }
      if (((*(s1 + i)) == 0) && (*(s2 + i))) {
        if (((*(s2 + i) >= '0') && (*(s2 + i) <= '9')))
          return (-1);
      } else if (((*(s2 + i)) == 0) && (*(s1 + i))) {
        if (((*(s1 + i) >= '0') && (*(s1 + i) <= '9')))
          return (1);
      }
    }
 
    if (n1 == n2) {
      if (*s1 < *s2)
        return (-1);
      else if (*s1 > *s2)
        return (1);
    } else if (n1 == 0) {
      return (-1);
    } else {
      return (1);
    }
  }
  if (*s1)
    return (1);
  else if (*s2)
    return (-1);
  return (0);
}

unescape_wildcards()

char * unescape_wildcards

(

char *

template

)

Remove escape characters from wildcard characters in a template string.

Processes the input template string and removes backslashes preceding wildcard characters ('*', '?', '[', ']'). This function modifies the string in place.

Parameters

template

The wildcard template string to unescape.

Returns

A pointer to the modified template string with escape characters removed.

Definition at line 534 of file wild_match.c.

                                         {
  char *ptr;
 
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_MANY))) {
    if (ptr != template && *(ptr - 1) == ESCAPE_CHAR) {
      strcpy_ss(ptr - 1, ptr);
    }
    ptr++;
  }
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_ONE))) {
    if (ptr != template && *(ptr - 1) == ESCAPE_CHAR) {
      strcpy_ss(ptr - 1, ptr);
    }
    ptr++;
  }
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_SET1))) {
    if (ptr != template && *(ptr - 1) == ESCAPE_CHAR) {
      strcpy_ss(ptr - 1, ptr);
    }
    ptr++;
  }
  ptr = template;
  while ((ptr = strchr(ptr, MATCH_SET2))) {
    if (ptr != template && *(ptr - 1) == ESCAPE_CHAR) {
      strcpy_ss(ptr - 1, ptr);
    }
    ptr++;
  }
  return (template);
}

wild_match()

int wild_match	(	char *	string,
		char *	template )

Determine whether one string is a wildcard match for another.

Compares the input string against a template that may include wildcard characters such as '*', '?', and character sets defined within brackets. Supports inversion of match results using the '^' character.

Parameters

string	The string to be matched.
template	The wildcard pattern to match against.

Returns

Returns 1 if the string matches the template, 0 otherwise.

Definition at line 49 of file wild_match.c.

                                             {
  char *s, *t, *ptr;
  int len, at_least, invert_set_match, invert_match;
 
#ifdef DEBUG
  printf("wild_match(%s, %s)\n", string, template);
#endif
 
  s = string; /* string to check for match */
  len = strlen(s);
  t = template; /* template string, with possible wildcards */
  if (*t == MATCH_INVERT) {
    invert_match = -1;
    t++;
  } else
    invert_match = 0;
 
  if (!*s) {
    if (!*t)
      return (!invert_match);
    return invert_match;
  } else if (!*t) {
    return invert_match;
  }
 
  do {
#ifdef DEBUG
    printf("s = %s,  t = %s\n", s, t);
#endif
    switch (*t) {
    case ESCAPE_CHAR:
      t++;
      if (*t++ != *s++)
        return (invert_match);
      len--;
      break;
    case MATCH_MANY:
      at_least = 0;
      while (*t) {
        if (*t == MATCH_MANY)
          t++;
        else if (*t == MATCH_ONE) {
          at_least++;
          t++;
        } else
          break;
      }
      if (at_least > len)
        return (invert_match);
      s += at_least;
      if (*t == 0 && *(t - 1) == MATCH_MANY) {
#ifdef DEBUG
        printf("return(1)\n");
#endif
        return (!invert_match);
      }
      ptr = s;
      while (*ptr) {
        if (wild_match(ptr, t)) {
#ifdef DEBUG
          printf("return(2)\n");
#endif
          return (!invert_match);
        }
        ptr++;
      }
      ptr = s;
      while ((ptr = strchr(ptr, *t))) {
        if (wild_match(ptr + 1, t + 1)) {
#ifdef DEBUG
          printf("return(3)\n");
#endif
          return (!invert_match);
        }
        if (*++ptr)
          ++ptr;
      }
      return (invert_match);
    case MATCH_ONE:
      s++;
      t++;
      len--;
      break;
    case MATCH_SET1:
      ptr = NULL;
      if (!*(t + 1) || !(ptr = strchr(t + 1, MATCH_SET2))) {
        if (*++t != *++s)
          return (invert_match);
        len--;
      } else {
        *ptr++ = 0;
        t++;
        SWAP_PTR(ptr, t);
        invert_set_match = 0;
        if (*ptr == SET_MATCH_INVERT && strlen(ptr) != 1) {
          invert_set_match = 1;
          ptr++;
        }
        if (strchr(ptr, *s)) {
          *(t - 1) = MATCH_SET2;
          if (invert_set_match)
            return (invert_match);
          s++;
          len--;
        } else {
          *(t - 1) = MATCH_SET2;
          if (!invert_set_match)
            return (invert_match);
          s++;
          len--;
        }
      }
      break;
    default:
      if (*s++ != *t++)
        return (invert_match);
      len--;
      break;
    }
  } while (*s && *t);
#ifdef DEBUG
  printf("s = %s,  t = %s\n", s, t);
#endif
  if (!*s && !*t) {
#ifdef DEBUG
    printf("return(5)\n");
#endif
    return (!invert_match);
  }
  if (!*s && *t == MATCH_MANY && !*(t + 1)) {
#ifdef DEBUG
    printf("return(4)\n");
#endif
    return (!invert_match);
  }
  if (*s && !*t) {
#ifdef DEBUG
    printf("return(6)\n");
#endif
    return (invert_match);
  }
  if (!*s && *t) {
    while (*t) {
      if (*t != MATCH_MANY) {
#ifdef DEBUG
        printf("return(7)\n");
#endif
        return (invert_match);
      }
      t++;
    }
#ifdef DEBUG
    printf("return(8)\n");
#endif
    return !invert_match;
  }
  bomb("the impossible has happened (wild_match)", NULL);
  exit(1);
}

wild_match_ci()

int wild_match_ci	(	char *	string,
		char *	template )

Determine whether one string is a case-insensitive wildcard match for another.

Similar to wild_match, but performs case-insensitive comparisons between the input string and the template. Handles wildcard characters and supports inversion of match results.

Parameters

string	The string to be matched, case-insensitively.
template	The wildcard pattern to match against, case-insensitively.

Returns

Returns 1 if the string matches the template, 0 otherwise.

Definition at line 220 of file wild_match.c.

                                                {
  char *s, *t, *ptr;
  int len, at_least, invert_set_match, invert_match;
 
  s = string; /* string to check for match */
  len = strlen(s);
  t = template; /* template string, with possible wildcards */
  if (*t == MATCH_INVERT) {
    invert_match = -1;
    t++;
  } else
    invert_match = 0;
 
  if (!*s) {
    if (!*t)
      return (!invert_match);
    return invert_match;
  } else if (!*t) {
    return invert_match;
  }
 
  do {
#ifdef DEBUG
    printf("s = %s,  t = %s\n", s, t);
#endif
    switch (*t) {
    case ESCAPE_CHAR:
      t++;
      if (tolower(*t) != tolower(*s))
        return (invert_match);
      t++;
      s++;
      len--;
      break;
    case MATCH_MANY:
      at_least = 0;
      while (*t) {
        if (*t == MATCH_MANY)
          t++;
        else if (*t == MATCH_ONE) {
          at_least++;
          t++;
        } else
          break;
      }
      if (at_least > len)
        return (invert_match);
      s += at_least;
      if (*t == 0 && *(t - 1) == MATCH_MANY) {
#ifdef DEBUG
        printf("return(1)\n");
#endif
        return (!invert_match);
      }
      ptr = s;
      while (*ptr) {
        if (wild_match_ci(ptr, t)) {
#ifdef DEBUG
          printf("return(2)\n");
#endif
          return (!invert_match);
        }
        ptr++;
      }
      ptr = s;
      while ((ptr = strchr_ci(ptr, *t))) {
        if (wild_match_ci(ptr + 1, t + 1)) {
#ifdef DEBUG
          printf("return(3)\n");
#endif
          return (!invert_match);
        }
        if (*++ptr)
          ++ptr;
      }
      return (invert_match);
    case MATCH_ONE:
      s++;
      t++;
      len--;
      break;
    case MATCH_SET1:
      ptr = NULL;
      if (!*(t + 1) || !(ptr = strchr_ci(t + 1, MATCH_SET2))) {
        if (tolower(*t) != tolower(*s))
          return (invert_match);
        t++;
        s++;
        len--;
      } else {
        *ptr++ = 0;
        t++;
        SWAP_PTR(ptr, t);
        invert_set_match = 0;
        if (*ptr == SET_MATCH_INVERT && strlen(ptr) != 1) {
          invert_set_match = 1;
          ptr++;
        }
        if (strchr_ci(ptr, *s)) {
          *(t - 1) = MATCH_SET2;
          if (invert_set_match)
            return (invert_match);
          s++;
          len--;
        } else {
          *(t - 1) = MATCH_SET2;
          if (!invert_set_match)
            return (invert_match);
          s++;
          len--;
        }
      }
      break;
    default:
      if (tolower(*s) != tolower(*t))
        return (invert_match);
      t++;
      s++;
      len--;
      break;
    }
  } while (*s && *t);
#ifdef DEBUG
  printf("s = %s,  t = %s\n", s, t);
#endif
  if (!*s && !*t) {
#ifdef DEBUG
    printf("return(5)\n");
#endif
    return (!invert_match);
  }
  if (!*s && *t == MATCH_MANY && !*(t + 1)) {
#ifdef DEBUG
    printf("return(4)\n");
#endif
    return (!invert_match);
  }
  if (*s && !*t) {
#ifdef DEBUG
    printf("return(6)\n");
#endif
    return (invert_match);
  }
  if (!*s && *t) {
    while (*t) {
      if (*t != MATCH_MANY) {
#ifdef DEBUG
        printf("return(7)\n");
#endif
        return (invert_match);
      }
      t++;
    }
#ifdef DEBUG
    printf("return(8)\n");
#endif
    return !invert_match;
  }
  bomb("the impossible has happened (wild_match_ci)", NULL);
  exit(1);
}