/*****************************************************************
| amatch - match a string against a wildcard pattern
|----------------------------------------------------------------
| Compares a data string against a test pattern using Bourne shell
| wildcard rules (*not* regular expression rules).
|
| This routine is ugly and not well structured.
|
| Author: Bill Davidsen (davidsen@crdos1.crd.ge.com) Mar 24, 1985
| with helpful suggestions from Andy Robinson
|----------------------------------------------------------------
| Copyright:
| Copyright (c) 1985, 1989 by Bill Davidsen. This program may be
| freely given, bartered, traded or sold by anyone for any
| purpose. The supplier assumes all risk for any consequences of
| malfunction. All other rights reserved.
|----------------------------------------------------------------
| Arguments:
| 1 - address of wildcard pattern
| 2 - address of string to test
****************************************************************/
#include <string.h>
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
int amatch(register char *ts, register char *cs)
{
int low, hi, notf;
while (1) { /* keep going until done */
if (*cs == '\0') { /* out of string */
for (; *ts == '*'; ++ts)
; /* get rid of extra '*' */
return(*ts == '\0');
}
switch (*ts) {
case '\0':
return(FALSE);
case '[': /* the hardest case (see '*' below) */
/* is the not flag set? */
if (notf = (*(ts + 1) == '!'))
++ts; /* ! flag set */
/* loop through the bracket */
while (*++ts != ']' && *ts != '\0') {
if (*ts == '-') { /* a range of values */
/* get lower limit */
if ((*--ts == '[' || *ts == '!')
&& *(ts - 1) != '\\')
low = '\0';
else
low = *ts;
/* get upper limit */
if (*(ts += 2) == ']' || *ts == '\0') {
hi = '\377';
--ts;
}
else {
if (*ts == '\\' &&
*++ts == '\0') {
--ts;
hi = '\377';
}
else
hi = *ts;
}
/* and compare */
if (*cs > (char) low && *cs <= (char) hi)
goto foo;
continue; /* in bracket loop */
}
/* process wildcard */
if (*ts == '\\' && *++ts == '\0')
break; /* bump and check for \0 */
/* check if they are the same */
if (*cs == *ts)
goto foo;
} /* while */
/* get here if no match (out of ts or reached ]) */
if (!notf)
return(FALSE);
if (*ts)
++ts;
break;
/* come here if a match */
foo: if (notf)
return(FALSE);
++ts;
while (*ts != '\0' && *ts++ != ']')
; /* get to end of bracket */
break;
case '*': /* a chicken way out! my only recursive part */
while (*++ts == '*')
; /* get rid of extra '*' */
if (!*ts) /* trailing '*' matches anything */
return(TRUE);
do
if (amatch(ts, cs))
return(TRUE);
while (*++cs);
return(*ts == '\0');
case '?': /* just bump the pointers */
++ts;
break;
case '\\': /* this drops through to next one */
++ts;
default: /* if they ain't the same here forget it */
if (*cs != *ts++)
return(FALSE);
} /* switch */
++cs;
} /* while (1) */
} /* match */
/*****************************************************************
| test program for amatch
|----------------------------------------------------------------
| Reads patterns and paths until none given.
****************************************************************/
#ifdef TEST
#include <stdio.h>
static void getline(char *buffer, int len);
void main(void)
{
char data[80], pattern[80];
int match;
do {
/* read wildcard patterns */
printf("Enter pattern: ");
getline(pattern, 80);
if (strlen(pattern)) {
/* read test cases */
do {
printf(" Enter test data: ");
getline(data, 80);
if (strlen(data)) {
match = amatch(pattern, data);
printf("\t%s\n", (match ? "YES" : "NO"));
}
} while (strlen(data));
}
} while (strlen(pattern));
}
static void getline(char *buffer, int len)
{
fgets(buffer, len, stdin);
len = strlen(buffer) - 1;
if (buffer[len] == '\n') buffer[len] = 0;
}
#endif
