/*static char *SCCSID = "@(#)qmatch.c 13.7 90/08/13";*/
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#define ASCLEN 128 /* Number of ascii characters */
#define BUFLEN 256 /* Temporary buffer length */
#define EOS ('\r') /* End of string character */
#define PATMAX 512 /* Maximum parsed pattern length */
#define BEGLINE 0x08 /* Match at beginning of line */
#define DEBUG 0x20 /* Print debugging output */
#define ENDLINE 0x10 /* Match at end of line */
#define T_END 0 /* End of expression */
#define T_STRING 1 /* String to match */
#define T_SINGLE 2 /* Single character to match */
#define T_CLASS 3 /* Class to match */
#define T_ANY 4 /* Match any character */
#define T_STAR 5 /* *-expr */
typedef struct exprnode
{
struct exprnode *ex_next; /* Next node in list */
unsigned char *ex_pattern; /* Pointer to pattern to match */
}
EXPR; /* Expression node */
static int clists = 1; /* One is first available index */
static int toklen[] = /* Table of token lengths */
{
32767, /* T_END: invalid */
32767, /* T_STRING: invalid */
2, /* T_SINGLE */
ASCLEN/8+1, /* T_CLASS */
1, /* T_ANY */
32767 /* T_STAR: invalid */
};
int ( __cdecl *ncmp)(const char *,const char *,size_t);
/* String comparison pointer */
unsigned char *exprparse(unsigned char *p);
extern int casesen; /* Case-sensitivity flag */
extern char *(*find)(); /* Pointer to search function */
extern int flags; /* Flags */
extern int strcnt; /* String count */
extern char transtab[]; /* Translation table */
EXPR *stringlist[ASCLEN];
/* String table */
void addexpr(char *e, int n); /* Add expression */
char *get1stcharset(unsigned char *e, char *bitvec);
extern char *alloc(); /* User-defined heap allocator */
unsigned char *simpleprefix();/* Match simple prefix */
char *strnupr(); /* See QGREPSUB.ASM */
unsigned char *simpleprefix(s,pp)
register unsigned char *s; /* String pointer */
unsigned char **pp; /* Pointer to pattern pointer */
{
register unsigned char *p; /* Simple pattern pointer */
register int c; /* Single character */
p = *pp; /* Initialize */
while(*p != T_END && *p != T_STAR) /* While not at end of pattern */
{
switch(*p++) /* Switch on token type */
{
case T_STRING: /* String to compare */
if((*ncmp)(s,p + 1,*p) != 0) return(NULL);
/* Fail if mismatch found */
s += *p; /* Skip matched portion */
p += *p + 1; /* Skip to next token */
break;
case T_SINGLE: /* Single character */
c = *s++; /* Get character */
if(!casesen) c = toupper(c);
/* Map to upper case if necessary */
if(c != (int)*p++) return(NULL);
/* Fail if mismatch found */
break;
case T_CLASS: /* Class of characters */
if(!isascii(*s) || !(p[*s >> 3] & (1 << (*s & 7)))) return(NULL);
/* Failure if bit not set */
p += ASCLEN/8; /* Skip bit vector */
++s; /* Skip character */
break;
case T_ANY: /* Any character */
if(*s++ == EOS) return(NULL);
/* Match all but end of string */
break;
}
}
*pp = p; /* Update pointer */
return(s); /* Pattern is prefix of s */
}
int match(s,p)
register unsigned char *s; /* String to match */
unsigned char *p; /* Pattern to match against */
{
register unsigned char *q; /* Temporary pointer */
unsigned char *r; /* Temporary pointer */
register int c; /* Character */
if(*p != T_END && *p != T_STAR && (s = simpleprefix(s,&p)) == NULL)
return(0); /* Failure if prefix mismatch */
if(*p++ == T_END) return(1); /* Match if end of pattern */
q = r = p; /* Point to repeated token */
r += toklen[*q]; /* Skip repeated token */
switch(*q++) /* Switch on token type */
{
case T_ANY: /* Any character */
while(match(s,r) == 0) /* While match not found */
{
if(*s++ == EOS) return(0);/* Match all but end of string */
}
return(1); /* Success */
case T_SINGLE: /* Single character */
while(match(s,r) == 0) /* While match not found */
{
c = *s++; /* Get character */
if(!casesen) c = toupper(c);
/* Map to upper case if necessary */
if((unsigned char) c != *q) return(0);
/* Fail if mismatch found */
}
return(1); /* Success */
case T_CLASS: /* Class of characters */
while(match(s,r) == 0) /* While match not found */
{
if(!isascii(*s) || !(q[*s >> 3] & (1 << (*s & 7)))) return(0);
/* Fail if bit not set */
++s; /* Else skip character */
}
return(1); /* Success */
}
return(0); /* Return failure */
}
int exprmatch(s,p)
char *s; /* String */
char *p; /* Pattern */
{
ncmp = strncmp; /* Assume case-sensitive */
if(!casesen)
{
ncmp = _strnicmp;
} /* Be case-insensitive if flag set */
return(match(s,p)); /* See if pattern matches string */
}
void bitset(bitvec,first,last,bitval)
char *bitvec; /* Bit vector */
int first; /* First character */
int last; /* Last character */
int bitval; /* Bit value (0 or 1) */
{
int bitno; /* Bit number */
bitvec += first >> 3; /* Point at first byte */
bitno = first & 7; /* Calculate first bit number */
while(first <= last) /* Loop to set bits */
{
if(bitno == 0 && first + 8 <= last)
{ /* If we have a whole byte's worth */
*bitvec++ = (char)(bitval? '\xFF': '\0');
/* Set the bits */
first += 8; /* Increment the counter */
continue; /* Next iteration */
}
*bitvec=(char)(*bitvec & (unsigned char)(~(1 << bitno))) | (unsigned char)(bitval << bitno);
/* Set the appropriate bit */
if(++bitno == 8) /* If we wrap into next byte */
{
++bitvec; /* Increment pointer */
bitno = 0; /* Reset bit index */
}
++first; /* Increment bit index */
}
}
unsigned char *exprparse(p)
register unsigned char *p; /* Raw pattern */
{
register char *cp; /* Char pointer */
unsigned char *cp2; /* Char pointer */
int i; /* Counter/index */
int j; /* Counter/index */
int m; /* Counter/index */
int n; /* Counter/index */
int bitval; /* Bit value */
char buffer[PATMAX]; /* Temporary buffer */
if(!casesen) strnupr(p,strlen(p)); /* Force pattern to upper case */
cp = buffer; /* Initialize pointer */
if(*p == '^') *cp++ = *p++; /* Copy leading caret if any */
while(*p != '\0') /* While not end of pattern */
{
i = -2; /* Initialize */
for(n = 0;;) /* Loop to delimit ordinary string */
{
n += strcspn(p + n,".\\[*");/* Look for a special character */
if(p[n] != '\\') break; /* Break if not backslash */
i = n; /* Remember where backslash is */
if(p[++n] == '\0') return(NULL);
/* Cannot be at very end */
++n; /* Skip escaped character */
}
if(p[n] == '*') /* If we found a *-expr. */
{
if(n-- == 0) return(NULL); /* Illegal first character */
if(i == n - 1) n = i; /* Escaped single-char. *-expr. */
}
if(n > 0) /* If we have string or single */
{
if(n == 1 || (n == 2 && *p == '\\'))
{ /* If single character */
*cp++ = T_SINGLE; /* Set type */
if(*p == '\\') ++p; /* Skip escape if any */
*cp++ = *p++; /* Copy single character */
}
else /* Else we have a string */
{
*cp++ = T_STRING; /* Set type */
cp2 = cp++; /* Save pointer to length byte */
while(n-- > 0) /* While bytes to copy remain */
{
if(*p == '\\') /* If escape found */
{
++p; /* Skip escape */
--n; /* Adjust length */
}
*cp++ = *p++; /* Copy character */
}
*cp2 = (char)((cp - cp2) - 1);
/* Set string length */
}
}
if(*p == '\0') break; /* Break if end of pattern */
if(*p == '.') /* If matching any */
{
if(*++p == '*') /* If star follows any */
{
++p; /* Skip star, too */
*cp++ = T_STAR; /* Insert prefix ahead of token */
}
*cp++ = T_ANY; /* Match any character */
continue; /* Next iteration */
}
if(*p == '[') /* If character class */
{
if(*++p == '\0') return(NULL);
/* Skip '[' */
*cp++ = T_CLASS; /* Set type */
memset(cp,'\0',ASCLEN/8); /* Clear the vector */
bitval = 1; /* Assume we're setting bits */
if(*p == '^') /* If inverted class */
{
++p; /* Skip '^' */
memset(cp,'\xFF',ASCLEN/8);
/* Set all bits */
bitset(cp,EOS,EOS,0); /* All except end-of-string */
bitset(cp,'\n','\n',0); /* And linefeed! */
bitval = 0; /* Now we're clearing bits */
}
while(*p != ']') /* Loop to find ']' */
{
if(*p == '\0') return(NULL);
/* Check for malformed string */
if(*p == '\\') /* If escape found */
{
if(*++p == '\0') return(NULL);
/* Skip escape */
}
i = *p++; /* Get first character in range */
if(*p == '-' && p[1] != '\0' && p[1] != ']')
{ /* If range found */
++p; /* Skip hyphen */
if(*p == '\\' && p[1] != '\0') ++p;
/* Skip escape character */
j = *p++; /* Get end of range */
}
else j = i; /* Else just one character */
bitset(cp,i,j,bitval); /* Set bits in vector */
if(!casesen) /* If ignoring case */
{
m = (i < 'A')? 'A': i;
/* m = max(i,'A') */
n = (j > 'Z')? 'Z': j;
/* n = min(j,'Z') */
if(m <= n) bitset(cp,tolower(m),tolower(n),bitval);
/* Whack corresponding lower case */
m = (i < 'a')? 'a': i;
/* m = max(i,'a') */
n = (j > 'z')? 'z': j;
/* n = min(j,'z') */
if(m <= n) bitset(cp,toupper(m),toupper(n),bitval);
/* Whack corresponding upper case */
}
}
if(*++p == '*') /* If repeated class */
{
memmove(cp,cp - 1,ASCLEN/8 + 1);
/* Move vector forward 1 byte */
cp[-1] = T_STAR; /* Insert prefix */
++cp; /* Skip to start of vector */
++p; /* Skip star */
}
cp += ASCLEN/8; /* Skip over vector */
continue; /* Next iteration */
}
*cp++ = T_STAR; /* Repeated single character */
*cp++ = T_SINGLE;
if(*p == '\\') ++p; /* Skip escape if any */
*cp++ = *p++; /* Copy the character */
assert(*p == '*'); /* Validate assumption */
++p; /* Skip the star */
}
*cp++ = T_END; /* Mark end of parsed expression */
cp2 = alloc(cp - buffer); /* Allocate buffer */
memmove(cp2,buffer,(size_t)(cp - buffer)); /* Copy expression to buffer */
return(cp2); /* Return buffer pointer */
}
int istoken(s,n)
unsigned char *s; /* String */
int n; /* Length */
{
if(n >= 2 && s[0] == '\\' && s[1] == '<') return(1);
/* Token if starts with '\<' */
while(n-- > 0) /* Loop to find end of string */
{
if(*s++ == '\\') /* If escape found */
{
if(--n == 0 && *s == '>') return(1);
/* Token if ends with '\>' */
++s; /* Skip escaped character */
}
}
return(0); /* Not a token */
}
int isexpr(s,n)
unsigned char *s; /* String */
int n; /* Length */
{
unsigned char *cp; /* Char pointer */
int status; /* Return status */
char buffer[BUFLEN]; /* Temporary buffer */
if(istoken(s,n)) return(1); /* Tokens are exprs */
memmove(buffer,s,n); /* Copy string to buffer */
buffer[n] = '\0'; /* Null-terminate string */
if((s = exprparse(buffer)) == NULL) return(0);
/* Not an expression if parse fails */
status = 1; /* Assume we have an expression */
if(*s != '^' && *s != T_END) /* If no caret and not empty */
{
status = 0; /* Assume not an expression */
cp = s; /* Initialize */
do /* Loop to find special tokens */
{
switch(*cp++) /* Switch on token type */
{
case T_STAR: /* Repeat prefix */
case T_CLASS: /* Character class */
case T_ANY: /* Any character */
++status; /* This is an expression */
break;
case T_SINGLE: /* Single character */
++cp; /* Skip character */
break;
case T_STRING: /* String */
cp += *cp + 1; /* Skip string */
break;
}
}
while(!status && *cp != T_END); /* Do while not at end of expression */
}
free(s); /* Free expression */
return(status); /* Return status */
}
void exprprint(p,fo)
unsigned char *p; /* Pointer to expression */
FILE *fo; /* File pointer */
{
int bit; /* Bit value */
int count; /* Count of characters in string */
int first; /* First character in range */
int last; /* Last character in range */
int star; /* Repeat prefix flag */
if(*p == '^') fputc(*p++,fo); /* Print leading caret */
while(*p != T_END) /* While not at end of expression */
{
star = 0; /* Assume no prefix */
if(*p == T_STAR) /* If repeat prefix found */
{
++star; /* Set flag */
++p; /* Skip prefix */
}
switch(*p++) /* Switch on token type */
{
case T_END: /* End of expression */
case T_STAR: /* Repeat prefix */
fprintf(stderr,"Internal error: exprprint\n");
/* Not valid */
exit(2); /* Die abnormal death */
case T_STRING: /* String */
count = *p++; /* Get string length */
goto common; /* Forgive me, Djikstra! */
case T_SINGLE: /* Single character */
count = 1; /* Only one character */
common:
while(count-- > 0) /* While bytes remain */
{
if(*p == EOS) /* If end-of-string found */
{
++p; /* Skip character */
fputc('$',fo); /* Emit special marker */
continue; /* Next iteration */
}
if(strchr("*.[\\$",*p) != NULL) fputc('\\',fo);
/* Emit escape if needed */
fputc(*p++,fo); /* Emit the character */
}
break;
case T_ANY: /* Match any */
fputc('.',fo); /* Emit dot */
break;
case T_CLASS:
first = -1; /* Initialize */
fputc('[',fo); /* Open braces */
for(count = ' '; count <= '~'; ++count)
{ /* Loop through printable characters */
if((bit = p[count >> 3] & (1 << (count & 7))) != 0)
{ /* If bit is set */
if(first == -1) first = count;
/* Set first bit */
last = count; /* Set last bit */
}
if((!bit || count == '~') && first != -1)
{ /* If range to print */
if(strchr("\\]-",first) != NULL) fputc('\\',fo);
/* Emit escape if needed */
fputc(first,fo); /* Print first character in range */
if(last != first) /* If we have a range */
{
if(last > first + 1) fputc('-',fo);
/* Emit hyphen if needed */
if(strchr("\\]-",last) != NULL) fputc('\\',fo);
/* Emit escape if needed */
fputc(last,fo);
/* Print last character in range */
}
first = -1; /* Range printed */
}
}
fputc(']',fo); /* Close braces */
p += ASCLEN/8; /* Skip bit vector */
break;
}
if(star) fputc('*',fo); /* Print star if needed */
}
fputc('\n',fo); /* Print newline */
}
char *get1stcharset(e,bitvec)
unsigned char *e; /* Pointer to expression */
char *bitvec; /* Pointer to bit vector */
{
unsigned char *cp; /* Char pointer */
int i; /* Index/counter */
int star; /* Repeat prefix flag */
if(*e == '^') ++e; /* Skip leading caret if any */
memset(bitvec,'\0',ASCLEN/8); /* Clear bit vector */
cp = e; /* Initialize */
while(*e != T_END) /* Loop to process leading *-expr.s */
{
star = 0; /* Assume no repeat prefix */
if(*e == T_STAR) /* If repeat prefix found */
{
++star; /* Set flag */
++e; /* Skip repeat prefix */
}
switch(*e++) /* Switch on token type */
{
case T_END: /* End of expression */
case T_STAR: /* Repeat prefix */
fprintf(stderr,"Internal error: get1stcharset\n");
/* Not valid */
exit(2); /* Die abnormal death */
case T_STRING: /* String */
if(star || *e++ == '\0') /* If repeat prefix or zero count */
{
fprintf(stderr,"Internal error: get1stcharset\n");
/* Not valid */
exit(2); /* Die abnormal death */
}
/* Drop through */
case T_SINGLE: /* Single character */
bitset(bitvec,*e,*e,1); /* Set the bit */
++e; /* Skip the character */
break;
case T_ANY: /* Match any */
memset(bitvec,'\xFF',ASCLEN/8);
/* Set all the bits */
bitset(bitvec,EOS,EOS,0); /* Except end-of-string */
bitset(bitvec,'\n','\n',0);
/* And linefeed! */
break;
case T_CLASS:
for(i = 0; i < ASCLEN/8; ++i) bitvec[i] |= *e++;
/* Or in all the bits */
break;
}
if(!star) break; /* Break if not repeated */
cp = e; /* Update pointer */
}
return(cp); /* Point to 1st non-repeated expr. */
}
char *findall(buffer,bufend)
char *buffer; /* Buffer in which to search */
char *bufend; /* End of buffer */
{
return(buffer < bufend? buffer: NULL);
/* Fail only on empty buffer */
}
void addtoken(e,n)
char *e; /* Raw token expression */
int n; /* Length of expression */
{
static char achpref[] = "^";/* Prefix */
static char achprefsuf[] = "[^A-Za-z0-9_]";
/* Prefix/suffix */
static char achsuf[] = "$"; /* Suffix */
char buffer[BUFLEN]; /* Temporary buffer */
assert(n >= 2); /* Must have at least two characters */
if(e[0] == '\\' && e[1] == '<') /* If begin token */
{
if(!(flags & BEGLINE)) /* If not matching at beginning only */
{
memcpy(buffer,achprefsuf,sizeof achprefsuf - 1);
/* Copy first prefix */
memcpy(buffer + sizeof achprefsuf - 1,e + 2,n - 2);
/* Attach expression */
addexpr(buffer,n + sizeof achprefsuf - 3);
/* Add expression */
}
memcpy(buffer,achpref,sizeof achpref - 1);
/* Copy second prefix */
memcpy(buffer + sizeof achpref - 1,e + 2,n - 2);
/* Attach expression */
addexpr(buffer,n + sizeof achpref - 3);
/* Add expression */
return; /* Done */
}
assert(e[n-2] == '\\' && e[n - 1] == '>');
/* Must be end token */
if(!(flags & ENDLINE)) /* If not matching at end only */
{
memcpy(buffer,e,n - 2); /* Copy expression */
memcpy(buffer + n - 2,achprefsuf,sizeof achprefsuf - 1);
/* Attach first suffix */
addexpr(buffer,n + sizeof achprefsuf - 3);
/* Add expression */
}
memcpy(buffer,e,n - 2); /* Copy expression */
memcpy(buffer + n - 2,achsuf,sizeof achsuf - 1);
/* Attach second suffix */
addexpr(buffer,n + sizeof achsuf - 3);
/* Add expression */
}
void addexpr(e,n)
char *e; /* Expression to add */
int n; /* Length of expression */
{
EXPR *expr; /* Expression node pointer */
int i; /* Index */
int j; /* Index */
int locflags; /* Local copy of flags */
char bitvec[ASCLEN/8];
/* First char. bit vector */
char buffer[BUFLEN]; /* Temporary buffer */
if(find == findall) return; /* Return if matching everything */
if(istoken(e,n)) /* If expr is token */
{
addtoken(e,n); /* Convert and add tokens */
return; /* Done */
}
locflags = flags; /* Initialize local copy */
if(*e == '^') locflags |= BEGLINE; /* Set flag if match must begin line */
j = -2; /* Assume no escapes in string */
for(i = 0; i < n - 1; ++i) /* Loop to find last escape */
{
if(e[i] == '\\') j = i++; /* Save index of last escape */
}
if(n > 0 && e[n-1] == '$' && j != n-2)
{ /* If expr. ends in unescaped '$' */
--n; /* Skip dollar sign */
locflags |= ENDLINE; /* Match must be at end */
}
strncpy(buffer,e,n); /* Copy pattern to buffer */
if(locflags & ENDLINE) buffer[n++] = EOS;
/* Add end character if needed */
buffer[n] = '\0'; /* Null-terminate string */
if((e = exprparse(buffer)) == NULL) return;
/* Return if invalid expression */
++strcnt; /* Increment string count */
if(!(locflags & BEGLINE)) /* If match needn't be at beginning */
{
e = get1stcharset(e,bitvec); /* Remove leading *-expr.s */
}
/*
* E now points to a buffer containing a preprocessed expression.
* We need to find the set of allowable first characters and make
* the appropriate entries in the string node table.
*/
if(*get1stcharset(e,bitvec) == T_END)
{ /* If expression will match anything */
find = findall; /* Match everything */
return; /* All done */
}
for(j = 0; j < ASCLEN; ++j) /* Loop to examine bit vector */
{
if(bitvec[j >> 3] & (1 << (j & 7)))
{ /* If the bit is set */
expr = (EXPR *) alloc(sizeof(EXPR));
/* Allocate record */
expr->ex_pattern = e; /* Point it at pattern */
if((i = transtab[j]) == 0) /* If no existing list */
{
if((i = clists++) >= ASCLEN)
{ /* If too many string lists */
fprintf(stderr,"Too many string lists\n");
/* Error message */
exit(2); /* Die */
}
stringlist[i] = NULL; /* Initialize */
transtab[j] = (char) i; /* Set pointer to new list */
if(!casesen && isalpha(j)) transtab[j ^ 0x20] = (char) i;
/* Set pointer for other case */
}
expr->ex_next = stringlist[i];
/* Link new record into table */
stringlist[i] = expr;
}
}
if(locflags & DEBUG) exprprint(e,stderr);
/* Print the expression if debugging */
}
char *findexpr(buffer,bufend)
unsigned char *buffer; /* Buffer in which to search */
char *bufend; /* End of buffer */
{
EXPR *expr; /* Expression list pointer */
unsigned char *pattern; /* Pattern */
int i; /* Index */
while(buffer < bufend) /* Loop to find match */
{
if((i = transtab[*buffer++]) == 0) continue;
/* Continue if not valid 1st char */
if((expr = (EXPR *) stringlist[i]) == NULL)
{ /* If null pointer */
fprintf(stderr,"Internal error: findexpr\n");
/* Print error message */
exit(2); /* Die */
}
--buffer; /* Back up to first character */
while(expr != NULL) /* Loop to find match */
{
pattern = expr->ex_pattern; /* Point to pattern */
expr = expr->ex_next; /* Point to next record */
if(pattern[0] == '^') /* If match begin line */
{
++pattern; /* Skip caret */
if(buffer[-1] != '\n') continue;
/* Don't bother if not at beginning */
}
if(exprmatch(buffer,pattern)) return(buffer);
/* Return pointer if match found */
}
++buffer; /* Skip first character */
}
return(NULL); /* No match */
}