windows-xp/Source/XPSP1/NT/sdktools/qgrep/qgrep.c

/*static char *SCCSID = "@(#)qgrep.c    13.11 90/08/14";*/
/*
 * QGrep
 *
 * Modification History:
 *
 *         Aug 1990     PeteS       Created.
 *             1990     DaveGi      Ported to Cruiser
 *      31-Oct-1990     W-Barry     Removed the #ifdef M_I386 'cause this
 *                                  code will never see 16bit again.
 */

#include                <stdio.h>
#include                <time.h>
#include                <stdlib.h>
#include                <string.h>
#include                <fcntl.h>
#include                <io.h>
#include                <windows.h>
#include                <ctype.h>
#include                <assert.h>

/*
 *  Miscellaneous constants and macros
 */

#define FILBUFLEN       (SECTORLEN*16)  /* File buffer length */
#define FILNAMLEN       80              /* File name length */
#define ISCOT           0x0002          /* Handle is console output */
#define LG2SECLEN       10              /* Log base two of sector length */
#define LNOLEN          12              /* Maximum line number length */
#define MAXSTRLEN       128             /* Maximum search string length */
#define OUTBUFLEN       (SECTORLEN*2)   /* Output buffer length */
#define PATHLEN         128             /* Path buffer length */
#define SECTORLEN       (1 << LG2SECLEN)/* Sector length */
#define STKLEN          512             /* Stack length in bytes */
#define TRTABLEN        256             /* Translation table length */
#define s_text(x)       (((char *)(x)) - ((x)->s_must))
/* Text field access macro */
#define EOS             ('\r')          /* End of string */


/*
 *  Bit flag definitions
 */

#define SHOWNAME        0x01            /* Print filename */
#define NAMEONLY        0x02            /* Print filename only */
#define LINENOS         0x04            /* Print line numbers */
#define BEGLINE         0x08            /* Match at beginning of line */
#define ENDLINE         0x10            /* Match at end of line */
#define DEBUG           0x20            /* Print debugging output */
#define TIMER           0x40            /* Time execution */
#define SEEKOFF         0x80            /* Print seek offsets */
#define ZLINENOS        0x100           /* Print MEP style line numbers */
#define DOQUOTES        0x200           /* Handle quoted strings in -f search file */


/*
 *  Type definitions
 */

typedef struct stringnode {
    struct stringnode   *s_alt;         /* List of alternates */
    struct stringnode   *s_suf;         /* List of suffixes */
    size_t               s_must;        /* Length of portion that must match */
}
STRINGNODE;     /* String node */

typedef ULONG           CBIO;           /* I/O byte count */
typedef ULONG           PARM;           /* Generic parameter */

typedef CBIO            *PCBIO;         /* Pointer to I/O byte count */
typedef PARM            *PPARM;         /* Pointer to generic parameter */


/*
 *  Global data
 */

char                    filbuf[FILBUFLEN*2L + 12];
char                    outbuf[OUTBUFLEN*2];
char                    td1[TRTABLEN] = { 0};
UINT_PTR                cchmin = (UINT_PTR)-1; /* Minimum string length */
UINT_PTR                chmax = 0;      /* Maximum character */
UINT_PTR                chmin = (UINT_PTR)-1; /* Minimum character */
char                    transtab[TRTABLEN] = { 0};
STRINGNODE              *stringlist[TRTABLEN/2];
int                     casesen = 1;    /* Assume case-sensitivity */
long                    cbfile;         /* Number of bytes in file */
static int              clists = 1;     /* One is first available index */
int                     filbuflen = FILBUFLEN;
/* File buffer length */
int                     flags;          /* Flags */
unsigned                lineno;         /* Current line number */
char                    *program;       /* Program name */
int                     status = 1;     /* Assume failure */
int                     strcnt = 0;     /* String count */
char                    target[MAXSTRLEN];
/* Last string added */
size_t                  targetlen;      /* Length of last string added */
unsigned                waste;          /* Wasted storage in heap */
int                     arrc;           /* I/O return code for DOSREAD */
char                    asyncio;        /* Asynchronous I/O flag */
int                     awrc = TRUE;    /* I/O return code for DOSWRITE */
char                    *bufptr[] = { filbuf + 4, filbuf + FILBUFLEN + 8};
CBIO                    cbread;         /* Bytes read by DOSREAD */
CBIO                    cbwrite;        /* Bytes written by DOSWRITE */
char                    *obuf[] = { outbuf, outbuf + OUTBUFLEN};
int                     ocnt[] = { OUTBUFLEN, OUTBUFLEN};
int                     oi = 0;         /* Output buffer index */
char                    *optr[] = { outbuf, outbuf + OUTBUFLEN};
char                    pmode;          /* Protected mode flag */
char                    *t2buf;         /* Async read buffer */
int                     t2buflen;       /* Async read buffer length */
HANDLE                  t2fd;           /* Async read file */
char                    *t3buf;         /* Async write buffer */
int                     t3buflen;       /* Async write buffer length */
HANDLE                  t3fd;           /* Async write file */

HANDLE                  readdone;       /* Async read done semaphore */
HANDLE                  readpending;    /* Async read pending semaphore */
HANDLE                  writedone;      /* Async write done semaphore */
HANDLE                  writepending;   /* Async write pending semaphore */

/*
 *  External functions and forward references
 */

void    addexpr( char *, int );                      /* See QMATCH.C */
void    addstring( char *, int );                    /* See below */
int     countlines( char *, char * );
char    *findexpr( unsigned char *, char *);         /* See QMATCH.C */
char    *findlist( unsigned char *, char * );
char    *findone( unsigned char *buffer, char *bufend );
void    flush1buf( void );                           /* See below */
void    flush1nobuf( void );                         /* See below */
int     grepbuffer( char *, char *, char * );        /* See below */
int     isexpr( unsigned char *, int );              /* See QMATCH.C */
void    matchstrings( char *, char *, int, size_t *, int * );
size_t  preveol( char * );
size_t  strncspn( char *, char *, size_t );
size_t  strnspn( char *, char *, size_t );
char    *strnupr( char *pch, int cch );
void    write1buf( char *, size_t );                    /* See below */
void    (*addstr)( char *, int ) = NULL;
char    *(*find)( unsigned char *, char * ) = NULL;
void    (*flush1)( void ) = flush1buf;
int     (*grep)( char *, char *, char * ) = grepbuffer;
void    (*write1)( char *, size_t ) = write1buf;


#include "windows.h"


void
ConvertAppToOem(
                unsigned argc,
                char* argv[]
                )
/*++

Routine Description:

    Converts the command line from ANSI to OEM, and force the app
    to use OEM APIs

Arguments:

    argc - Standard C argument count.

    argv - Standard C argument strings.

Return Value:

    None.

--*/

{
    unsigned i;

    for ( i=0; i<argc; i++ ) {
        CharToOem( argv[i], argv[i] );
    }
    SetFileApisToOEM();
}




void
error(
      char *mes
      )
{
    fprintf(stderr,"%s: %s\n",program,mes);
    /* Print message */
    exit(2);                            /* Die */
}


char *
alloc(
      size_t size
      )
{
    char                *cp;            /* Char pointer */

    if ((cp = malloc(size)) == NULL) {     /* If allocation fails */
        fprintf(stderr,"%s: Out of memory (%u)\n",program,waste);
        /* Write error message */
        exit(2);                        /* Die */
    }
    return(cp);                         /* Return pointer to buffer */
}


void
freenode(
         STRINGNODE *x
         )
{
    register STRINGNODE *y;             /* Pointer to next node in list */

    while (x != NULL) {                 /* While not at end of list */
        if (x->s_suf != NULL)
            freenode(x->s_suf);         /* Free suffix list if not end */
        else
            --strcnt;                   /* Else decrement string count */
        y = x;                          /* Save pointer */
        x = x->s_alt;                   /* Move down the list */
        free((char *)((INT_PTR) s_text(y) & ~(sizeof(DWORD_PTR)-1)));
        /* Free the node */
    }
}


STRINGNODE *
newnode(
        char *s,
        size_t n
        )
{
    register STRINGNODE *new;           /* Pointer to new node */
    char                *t;             /* String pointer */
    size_t               d;             /* rounds to a dword boundary */

    d = n & (sizeof(DWORD_PTR)-1) ? sizeof(DWORD_PTR) - (n & (sizeof(DWORD_PTR)-1)) : 0;        /* offset to next dword past n */
    t = alloc(sizeof(STRINGNODE) + n + d);
    /* Allocate string node */
    t += d;                             /* END of string word-aligned */
    strncpy(t,s,n);                     /* Copy string text */
    new = (STRINGNODE *)(t + n);        /* Set pointer to node */
    new->s_alt = NULL;                  /* No alternates yet */
    new->s_suf = NULL;                  /* No suffixes yet */
    new->s_must = n;                    /* Set string length */
    return(new);                        /* Return pointer to new node */
}


STRINGNODE *
reallocnode(
            STRINGNODE *node,
            char *s,
            int n
            )
{
    register char       *cp;            /* Char pointer */

    assert(n <= node->s_must);          /* Node must not grow */
    waste += (unsigned)(node->s_must - n);
    /* Add in wasted space */
    assert(sizeof(char *) == sizeof(INT_PTR));
    /* Optimizer should eliminate this */
    cp = (char *)((INT_PTR) s_text(node) & ~(sizeof(DWORD_PTR)-1));
    /* Point to start of text */
    node->s_must = n;                   /* Set new length */
    if (n & (sizeof(DWORD_PTR)-1)) 
         cp += sizeof(DWORD_PTR) - (n & (sizeof(DWORD_PTR)-1));        /* Adjust non dword-aligned string */
    memmove(cp,s,n);                    /* Copy new text */
    cp += n;                            /* Skip over new text */
    memmove(cp,node,sizeof(STRINGNODE));/* Copy the node */
    return((STRINGNODE *) cp);          /* Return pointer to moved node */
}


/***    maketd1 - add entry for TD1 shift table
 *
 *      This function fills in the TD1 table for the given
 *      search string.  The idea is adapted from Daniel M.
 *      Sunday's QuickSearch algorithm as described in an
 *      article in the August 1990 issue of "Communications
 *      of the ACM".  As described, the algorithm is suitable
 *      for single-string searches.  The idea to extend it for
 *      multiple search strings is mine and is described below.
 *
 *              Think of searching for a match as shifting the search
 *              pattern p of length n over the source text s until the
 *              search pattern is aligned with matching text or until
 *              the end of the source text is reached.
 *
 *              At any point when we find a mismatch, we know
 *              we will shift our pattern to the right in the
 *              source text at least one position.  Thus,
 *              whenever we find a mismatch, we know the character
 *              s[n] will figure in our next attempt to match.
 *
 *              For some character c, TD1[c] is the 1-based index
 *              from right to left of the first occurrence of c
 *              in p.  Put another way, it is the count of places
 *              to shift p to the right on s so that the rightmost
 *              c in p is aligned with s[n].  If p does not contain
 *              c, then TD1[c] = n + 1, meaning we shift p to align
 *              p[0] with s[n + 1] and try our next match there.
 *
 *              Computing TD1 for a single string is easy:
 *
 *                      memset(TD1,n + 1,sizeof TD1);
 *                      for (i = 0; i < n; ++i) {
 *                          TD1[p[i]] = n - i;
 *                      }
 *
 *              Generalizing this computation to a case where there
 *              are multiple strings of differing lengths is trickier.
 *              The key is to generate a TD1 that is as conservative
 *              as necessary, meaning that no shift value can be larger
 *              than one plus the length of the shortest string for
 *              which you are looking.  The other key is to realize
 *              that you must treat each string as though it were only
 *              as long as the shortest string.  This is best illustrated
 *              with an example.  Consider the following two strings:
 *
 *              DYNAMIC PROCEDURE
 *              7654321 927614321
 *
 *              The numbers under each letter indicate the values of the
 *              TD1 entries if we computed the array for each string
 *              separately.  Taking the union of these two sets, and taking
 *              the smallest value where there are conflicts would yield
 *              the following TD1:
 *
 *              DYNAMICPODURE
 *              7654321974321
 *
 *              Note that TD1['P'] equals 9; since n, the length of our
 *              shortest string is 7, we know we should not have any
 *              shift value larger than 8.  If we clamp our shift values
 *              to this value, then we get
 *
 *              DYNAMICPODURE
 *              7654321874321
 *
 *              Already, this looks fishy, but let's try it out on
 *              s = "DYNAMPROCEDURE".  We know we should match on
 *              the trailing procedure, but watch:
 *
 *              DYNAMPROCEDURE
 *              ^^^^^^^|
 *
 *              Since DYNAMPR doesn't match one of our search strings,
 *              we look at TD1[s[n]] == TD1['O'] == 7.  Applying this
 *              shift, we get
 *
 *              DYNAMPROCEDURE
 *                     ^^^^^^^
 *
 *              As you can see, by shifting 7, we have gone too far, and
 *              we miss our match.  When computing TD1 for "PROCEDURE",
 *              we must take only the first 7 characters, "PROCEDU".
 *              Any trailing characters can be ignored (!) since they
 *              have no effect on matching the first 7 characters of
 *              the string.  Our modified TD1 then becomes
 *
 *              DYNAMICPODURE
 *              7654321752163
 *
 *              When applied to s, we get TD1[s[n]] == TD1['O'] == 5,
 *              leaving us with
 *
 *              DYNAMPROCEDURE
 *                   ^^^^^^^
 *              which is just where we need to be to match on "PROCEDURE".
 *
 *      Going to this algorithm has speeded qgrep up on multi-string
 *      searches from 20-30%.  The all-C version with this algorithm
 *      became as fast or faster than the C+ASM version of the old
 *      algorithm.  Thank you, Daniel Sunday, for your inspiration!
 *
 *      Note: if we are case-insensitive, then we expect the input
 *      string to be upper-cased on entry to this routine.
 *
 *      Pete Stewart, August 14, 1990.
 */

void
maketd1(
        unsigned char *pch,
        UINT_PTR cch,
        UINT_PTR cchstart
        )
{
    UINT_PTR ch;                        /* Character */
    UINT_PTR i;                         /* String index */

    if ((cch += cchstart) > cchmin)
        cch = cchmin;                   /* Use smaller count */
    for (i = cchstart; i < cch; ++i) {  /* Examine each char left to right */
        ch = *pch++;                    /* Get the character */
        for (;;) {                      /* Loop to set up entries */
            if (ch < chmin)
                chmin = ch;             /* Remember if smallest */
            if (ch > chmax)
                chmax = ch;             /* Remember if largest */
            if (cchmin - i < (UINT_PTR) td1[ch])
                td1[ch] = (unsigned char)(cchmin - i);
            /* Set value if smaller than previous */
            if (casesen || !isascii((int)ch) || !isupper((int)ch))
                break;                  /* Exit loop if done */
            ch = tolower((int)ch);          /* Force to lower case */
        }
    }
}

static int
newstring(
          char *s,
          size_t n
          )
{
    register STRINGNODE *cur;           /* Current string */
    register STRINGNODE **pprev;        /* Pointer to previous link */
    STRINGNODE          *new;           /* New string */
    size_t              i;              /* Index */
    size_t              j;              /* Count */
    int                 k;              /* Count */

    if ( (UINT_PTR)n < cchmin)
        cchmin = n;                     /* Remember length of shortest string */
    if ((i = transtab[*s]) == 0) {         /* If no existing list */
        /*
         *  We have to start a new list
         */
        if ((i = clists++) >= TRTABLEN/2) error("Too many string lists");
        /* Die if too many string lists */
        stringlist[i] = NULL;           /* Initialize */
        transtab[*s] = (char) i;        /* Set pointer to new list */
        if (!casesen && isalpha(*s)) transtab[*s ^ '\040'] = (char) i;
        /* Set pointer for other case */
    } else if (stringlist[i] == NULL) return(0);
    /* Check for existing 1-byte string */
    if (--n == 0) {                        /* If 1-byte string */
        freenode(stringlist[i]);        /* Free any existing stuff */
        stringlist[i] = NULL;           /* No record here */
        ++strcnt;                       /* We have a new string */
        return(1);                      /* String added */
    }
    ++s;                                /* Skip first char */
    pprev = stringlist + i;             /* Get pointer to link */
    cur = *pprev;                       /* Get pointer to node */
    while (cur != NULL) {                  /* Loop to traverse match tree */
        i = (n > cur->s_must)? cur->s_must: n;
        /* Find minimum of string lengths */
        matchstrings(s,s_text(cur),i,&j,&k);
        /* Compare the strings */
        if (j == 0) {                      /* If complete mismatch */
            if (k < 0) break;            /* Break if insertion point found */
            pprev = &(cur->s_alt);      /* Get pointer to alternate link */
            cur = *pprev;               /* Follow the link */
        } else if (i == j) {                 /* Else if strings matched */
            if (i == n) {                  /* If new is prefix of current */
                cur = *pprev = reallocnode(cur,s_text(cur),n);
                /* Shorten text of node */
                if (cur->s_suf != NULL) {  /* If there are suffixes */
                    freenode(cur->s_suf);
                    /* Suffixes no longer needed */
                    cur->s_suf = NULL;
                    ++strcnt;           /* Account for this string */
                }
                return(1);              /* String added */
            }
            pprev = &(cur->s_suf);      /* Get pointer to suffix link */
            if ((cur = *pprev) == NULL) return(0);
            /* Done if current is prefix of new */
            s += i;                     /* Skip matched portion */
            n -= i;
        } else                            /* Else partial match */ {
            /*
             *  We must split an existing node.
             *  This is the trickiest case.
             */
            new = newnode(s_text(cur) + j,cur->s_must - j);
            /* Unmatched part of current string */
            cur = *pprev = reallocnode(cur,s_text(cur),j);
            /* Set length to matched portion */
            new->s_suf = cur->s_suf;    /* Current string's suffixes */
            if (k < 0) {                   /* If new preceded current */
                cur->s_suf = newnode(s + j,n - j);
                /* FIrst suffix is new string */
                cur->s_suf->s_alt = new;/* Alternate is part of current */
            } else                        /* Else new followed current */ {
                new->s_alt = newnode(s + j,n - j);
                /* Unmatched new string is alternate */
                cur->s_suf = new;       /* New suffix list */
            }
            ++strcnt;                   /* One more string */
            return(1);                  /* String added */
        }
    }
    *pprev = newnode(s,n);              /* Set pointer to new node */
    (*pprev)->s_alt = cur;              /* Attach alternates */
    ++strcnt;                           /* One more string */
    return(1);                          /* String added */
}


void
addstring(
          char *s,
          int n
          )
{
    int                 endline;        /* Match-at-end-of-line flag */
    register char       *pch;           /* Char pointer */

    endline = flags & ENDLINE;          /* Initialize flag */
    pch = target;                       /* Initialize pointer */
    while (n-- > 0) {                      /* While not at end of string */
        switch (*pch = *s++) {             /* Switch on character */
            case '\\':                  /* Escape */
                if (n > 0 && !isalnum(*s)) { /* If next character "special" */
                    --n;                  /* Decrement counter */
                    *pch = *s++;          /* Copy next character */
                }
                ++pch;                    /* Increment pointer */
                break;

            case '$':                   /* Special end character */
                if (n == 0) {                /* If end of string */
                    endline = ENDLINE;    /* Set flag */
                    break;                /* Exit switch */
                }
                /* Drop through */

            default:                    /* All others */
                ++pch;                    /* Increment pointer */
                break;
        }
    }
    if (endline)
        *pch++ = EOS;           /* Add end character if needed */
    targetlen = (int)(pch - target);     /* Compute target string length */
    if (!casesen)
        strnupr(target, targetlen);      /* Force to upper case if necessary */
    newstring(target, targetlen);        /* Add string */
}


int
addstrings(
           char *buffer,
           char *bufend,
           char *seplist
           )
{
    size_t len;            /* String length */

    while (buffer < bufend) {              /* While buffer not empty */
        len = strnspn(buffer, seplist, (size_t)(bufend - buffer));
        /* Count leading separators */
        if ((buffer += len) >= bufend) {
            break;                      /* Skip leading separators */
        }
        len = strncspn(buffer,seplist,(size_t)(bufend - buffer));
        /* Get length of search string */
        if (addstr == NULL) {
            addstr = isexpr( buffer, len ) ? addexpr : addstring;
            /* Select search string type */
        }
        if ( addstr == addexpr || (flags & BEGLINE) ||
             findlist( buffer, buffer + len ) == NULL) {                             /* If no match within string */
            (*addstr)(buffer,len);      /* Add string to list */
        }
        buffer += len;                  /* Skip the string */
    }
    return(0);                          /* Keep looking */
}


int
enumlist(
         STRINGNODE *node,
         int cchprev
         )
{
    int                 i;              /* Counter */
    int                 strcnt;         /* String count */

    strcnt = 0;                         /* Initialize */
    while (node != NULL) {                 /* While not at end of list */
        maketd1(s_text(node),node->s_must,cchprev);
        /* Make TD1 entries */
        if (flags & DEBUG) {              /* If verbose output wanted */
            for (i = 0; i < cchprev; ++i)
                fputc(' ',stderr);      /* Indent line */
            fwrite(s_text(node),sizeof(char),node->s_must,stderr);
            /* Write this portion */
            fprintf(stderr,"\n");       /* Newline */
        }
        strcnt += (node->s_suf != NULL)?
                  enumlist(node->s_suf,cchprev + node->s_must): 1;
        /* Recurse to do suffixes */
        node = node->s_alt;             /* Do next alternate in list */
    }
    return(strcnt? strcnt: 1);          /* Return string count */
}


int
enumstrings()
{
    char                ch;             /* Character */
    int                 i;              /* Index */
    int                 strcnt;         /* String count */

    strcnt = 0;                         /* Initialize */
    for (i = 0; i < TRTABLEN; ++i) {       /* Loop through translation table */
        if (casesen || !isascii(i) || !islower(i)) {                             /* If case sensitive or not lower */
            if (transtab[i] == 0)
                continue;               /* Skip null entries */
            ch = (char) i;              /* Get character */
            maketd1(&ch,1,0);           /* Make TD1 entry */
            if (flags & DEBUG)
                fprintf(stderr,"%c\n",i);
            /* Print the first byte */
            strcnt += enumlist(stringlist[transtab[i]],1);
            /* Enumerate the list */
        }
    }
    return(strcnt);                     /* Return string count */
}

HANDLE
openfile(
         char *name
         )
{
    HANDLE              fd;             /* File descriptor */
    DWORD               er;

    if ((fd = CreateFile( name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL ) ) == (HANDLE)-1)
    /* If error opening file */
    {
        er = GetLastError();
        fprintf(stderr,"%s: Cannot open %s (error = %x)\n",program,name,er);
        /* Print error message */
    }
    return( fd );                       /* Return file descriptor */
}

void
thread2()       /* Read thread */
{
    for (;;) {                             /* Loop while there is work to do */
        if ((WaitForSingleObject(readpending, (DWORD)-1L) != NO_ERROR)
            || (ResetEvent(readpending)              != TRUE)) {
            break;                      /* Exit loop if event error */
        }
        arrc = ReadFile(t2fd,(PVOID)t2buf,t2buflen, &cbread, NULL);
        /* Do the read */
        SetEvent( readdone );           /* Signal read completed */
    }
    error("Thread 2 semaphore error");  /* Print error message and die */
}


void
thread3()       /* Write thread */
{
    for (;;) {                             /* Loop while there is work to do */
        if ((WaitForSingleObject(writepending,(DWORD)-1L) != NO_ERROR)
            || (ResetEvent(writepending)              != TRUE)) {
            break;              /* Exit loop if event error */
        }
        awrc = WriteFile(t3fd,(PVOID)t3buf,t3buflen, &cbwrite, NULL);
        /* Do the write */
        SetEvent( writedone );          /* Signal write completed */
    }
    error("Thread 3 semaphore error");  /* Print error message and die */
}


void
startread(
          HANDLE fd,
          char *buffer,
          int buflen
          )
{
    if ( asyncio ) {                               /* If asynchronous I/O */
        if ((WaitForSingleObject(readdone,(DWORD)-1L) != NO_ERROR)
            || (ResetEvent(readdone)              != TRUE)) {
            error("read synch error");  /* Die if we fail to get semaphore */
        }
        t2fd = fd;                      /* Set parameters for read */
        t2buf = buffer;
        t2buflen = buflen;
        SetEvent( readpending );        /* Signal read to start */
        Sleep( 0L );                    /* Yield the CPU */
    } else {
        arrc = ReadFile(fd,(PVOID)buffer,buflen, &cbread, NULL);
    }
}


int
finishread()
{
    if (asyncio) {                         /* If asynchronous I/O */
        if ( WaitForSingleObject( readdone, (DWORD)-1L ) != NO_ERROR ) {
            error("read wait error");   /* Die if wait fails */
        }
    }
    return(arrc ? cbread : -1); /* Return number of bytes read */
}


void
startwrite(
           HANDLE fd,
           char *buffer,
           int buflen
           )
{
    if (asyncio) {                         /* If asynchronous I/O */
        if ((WaitForSingleObject(writedone,(DWORD)-1L) != NO_ERROR)
            || (ResetEvent(writedone)              != TRUE)) {
            error("write synch error"); /* Die if we fail to get semaphore */
        }
        t3fd = fd;                      /* Set parameters for write */
        t3buf = buffer;
        t3buflen = buflen;
        SetEvent( writepending );       /* Signal read completed */
        Sleep( 0L );                    /* Yield the CPU */
    } else {
        awrc = WriteFile(fd,(PVOID)buffer,buflen, &cbwrite, NULL);
    }
}


int
finishwrite()
{
    if (asyncio) {                         /* If asynchronous I/O */
        if ( WaitForSingleObject( writedone, (DWORD)-1L ) != NO_ERROR ) {
            error("write wait error");  /* Die if wait fails */
        }
    }
    return(awrc ? cbwrite : -1);    /* Return number of bytes written */
}


void
write1nobuf(
            char *buffer,
            size_t buflen
            )
{
    CBIO                cb;             /* Count of bytes written */

    if (!WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),(PVOID)buffer,buflen, &cb, NULL)
        ||  (cb != (CBIO)buflen))
    {
        error("Write error");           /* Die if write fails */
    }
}


void
write1buf(
          char *buffer,
          size_t buflen
          )
{
    register size_t cb;             /* Byte count */

    while (buflen > 0) {                   /* While bytes remain */
        if (!awrc) {                       /* If previous write failed */
            fprintf(stderr,"%s: Write error %d\n",program,GetLastError());
            /* Print error message */
            exit(2);                    /* Die */
        }
        if ((cb = ocnt[oi]) == 0) {        /* If buffer full */
            startwrite( GetStdHandle( STD_OUTPUT_HANDLE ), obuf[oi], OUTBUFLEN );
            /* Write the buffer */
            ocnt[oi] = OUTBUFLEN;       /* Reset count and pointer */
            optr[oi] = obuf[oi];
            oi ^= 1;                    /* Switch buffers */
            cb = ocnt[oi];              /* Get space remaining */
        }
        if (cb > buflen)
            cb = buflen;    /* Get minimum */
        memmove(optr[oi],buffer,cb);    /* Copy bytes to buffer */
        ocnt[oi] -= cb;                 /* Update buffer length and pointers */
        optr[oi] += cb;
        buflen -= cb;
        buffer += cb;
    }
}


void
flush1nobuf(void)
{
}


void
flush1buf(void)
{
    register int        cb;             /* Byte count */

    if ((cb = OUTBUFLEN - ocnt[oi]) > 0) { /* If buffer not empty */
        startwrite( GetStdHandle( STD_OUTPUT_HANDLE ), obuf[oi], cb );  /* Start write */
        if (finishwrite() != cb) {         /* If write failed */
            fprintf(stderr,"%s: Write error %d\n",program,GetLastError());
            /* Print error message */
            exit(2);                    /* Die */
        }
    }
}


int
grepnull(
         char *cp,
         char *endbuf,
         char *name
         )
{
    /* keep compiler happy */
    cp = cp;
    endbuf = endbuf;
    name = name;
    return(0);                          /* Do nothing */
}


int
grepbuffer(
           char *startbuf,
           char *endbuf,
           char *name
           )
{
    char                *cp;            /* Buffer pointer */
    char                *lastmatch;     /* Last matching line */
    int                 linelen;        /* Line length */
    int                 namlen = 0;     /* Length of name */
    char                lnobuf[LNOLEN]; /* Line number buffer */
    char                nambuf[PATHLEN];/* Name buffer */

    cp = startbuf;                      /* Initialize to start of buffer */
    lastmatch = cp;                     /* No previous match yet */
    while ((cp = (*find)(cp,endbuf)) != NULL) {                                 /* While matches are found */
        --cp;                           /* Back up to previous character */
        if ((flags & BEGLINE) && *cp != '\n') {                             /* If begin line conditions not met */
            cp += strncspn(cp,"\n", (size_t)(endbuf - cp)) + 1;
            /* Skip line */
            continue;                   /* Keep looking */
        }
        status = 0;                     /* Match found */
        if (flags & NAMEONLY) return(1); /* Return if filename only wanted */
        cp -= preveol(cp) - 1;          /* Point at start of line */
        if (flags & SHOWNAME) {            /* If name wanted */
            if (namlen == 0) {             /* If name not formatted yet */
                if (flags & ZLINENOS)
                    namlen = sprintf(nambuf,"%s",name);
                else
                    namlen = sprintf(nambuf,"%s:",name);
                /* Format name if not done already */
            }
            (*write1)(nambuf, namlen);   /* Show name */
        }
        if (flags & LINENOS) {             /* If line number wanted */
            lineno += countlines(lastmatch,cp);
            /* Count lines since last match */
            if (flags & ZLINENOS)
                (*write1)(lnobuf,sprintf(lnobuf,"(%u) : ",lineno));
            else
                (*write1)(lnobuf,sprintf(lnobuf,"%u:",lineno));
            /* Print line number */
            lastmatch = cp;             /* New last match */
        }
        if (flags & SEEKOFF) {             /* If seek offset wanted */
            (*write1)(lnobuf,sprintf(lnobuf,"%lu:",
                                     cbfile + (long)(cp - startbuf)));
            /* Print seek offset */
        }
        linelen = strncspn(cp,"\n",(size_t)(endbuf - cp)) + 1;
        /* Calculate line length */
        (*write1)(cp,linelen);          /* Print the line */
        cp += linelen;                  /* Skip the line */
    }
    if (flags & LINENOS)
        lineno += countlines(lastmatch,endbuf);
    /* Count remaining lines in buffer */
    return(0);                          /* Keep searching */
}


void
showv(
      char *name,
      char *startbuf,
      char *lastmatch,
      char *thismatch
      )
{
    register int        linelen;
    int                 namlen = 0;     /* Length of name */
    char                lnobuf[LNOLEN]; /* Line number buffer */
    char                nambuf[PATHLEN];/* Name buffer */

    if (flags & (SHOWNAME | LINENOS | SEEKOFF)) {
        while (lastmatch < thismatch) {
            if (flags & SHOWNAME) {        /* If name wanted */
                if (namlen == 0) {         /* If name not formatted yet */
                    if (flags & ZLINENOS)
                        namlen = sprintf(nambuf,"%s",name);
                    else
                        namlen = sprintf(nambuf,"%s:",name);
                    /* Format name if not done already */
                }
                (*write1)(nambuf,namlen);
                /* Write the name */
            }
            if (flags & LINENOS) {         /* If line numbers wanted */
                if (flags & ZLINENOS)
                    (*write1)(lnobuf,sprintf(lnobuf,"(%u) : ",lineno++));
                else
                    (*write1)(lnobuf,sprintf(lnobuf,"%u:",lineno++));
                /* Print the line number */
            }
            if (flags & SEEKOFF) {         /* If seek offsets wanted */
                (*write1)(lnobuf,sprintf(lnobuf,"%lu:",
                                         cbfile + (long)(lastmatch - startbuf)));
                /* Print the line number */
            }
            linelen = strncspn(lastmatch,"\n",(size_t)(thismatch - lastmatch)) + 1;
            (*write1)(lastmatch,linelen);
            lastmatch += linelen;
        }
    } else (*write1)(lastmatch, (size_t)(thismatch - lastmatch));
}


int
grepvbuffer(
            char *startbuf,
            char *endbuf,
            char *name
            )
{
    register char       *cp;            /* Buffer pointer */
    register char       *lastmatch;     /* Pointer to line after last match */

    cp = startbuf;                      /* Initialize to start of buffer */
    lastmatch = cp;
    while ((cp = (*find)(cp,endbuf)) != NULL) {
        --cp;                           /* Back up to previous character */
        if ((flags & BEGLINE) && *cp != '\n') {                             /* If begin line conditions not met */
            cp += strncspn(cp,"\n", (size_t)(endbuf - cp)) + 1;
            /* Skip line */
            continue;                   /* Keep looking */
        }
        cp -= preveol(cp) - 1;          /* Point at start of line */
        if (cp > lastmatch) {              /* If we have lines without matches */
            status = 0;                 /* Lines without matches found */
            if (flags & NAMEONLY) return(1);
            /* Skip rest of file if NAMEONLY */
            showv(name,startbuf,lastmatch,cp);
            /* Show from last match to this */
        }
        cp += strncspn(cp,"\n",(size_t)(endbuf - cp)) + 1;
        /* Skip over line with match */
        lastmatch = cp;                 /* New "last" match */
        ++lineno;                       /* Increment line count */
    }
    if (endbuf > lastmatch) {              /* If we have lines without matches */
        status = 0;                     /* Lines without matches found */
        if (flags & NAMEONLY) return(1); /* Skip rest of file if NAMEONLY */
        showv(name,startbuf,lastmatch,endbuf);
        /* Show buffer tail */
    }
    return(0);                          /* Keep searching file */
}

void
qgrep(
      int (*grep)( char *, char *, char * ),
      char *name,
      HANDLE fd
      )
{
    int                 cb;             /* Byte count */
    register char       *cp;            /* Buffer pointer */
    char                *endbuf;        /* End of buffer */
    int                 taillen;        /* Length of buffer tail */
    int                 bufi;           /* Buffer index */

    cbfile = 0L;                        /* File empty so far */
    lineno = 1;                         /* File starts on line 1 */
    taillen = 0;                        /* No buffer tail yet */
    bufi = 0;                           /* Initialize buffer index */
    cp = bufptr[0];                     /* Initialize to start of buffer */
    finishread();                       /* Make sure no I/O activity */
    arrc = ReadFile(fd,(PVOID)cp,filbuflen, &cbread, NULL);
    while ((cb = finishread()) + taillen > 0) {                                 /* While search incomplete */
        if (cb == 0) {                     /* If buffer tail is all that's left */
            taillen = 0;                /* Set tail length to zero */
            *cp++ = '\r';               /* Add end of line sequence */
            *cp++ = '\n';
            endbuf = cp;                /* Note end of buffer */
        } else                            /* Else start next read */ {
            taillen = preveol(cp + cb - 1);
            /* Find length of partial line */
            endbuf = cp + cb - taillen; /* Get pointer to end of buffer */
            cp = bufptr[bufi ^ 1];      /* Pointer to other buffer */
            memmove(cp,endbuf,taillen); /* Copy tail to head of other buffer */
            cp += taillen;              /* Skip over tail */
            startread(fd,cp,(filbuflen - taillen) & (~0 << LG2SECLEN));
            /* Start next read */
        }
        if ((*grep)(bufptr[bufi],endbuf,name)) {                             /* If rest of file can be skipped */
            (*write1)(name,strlen(name));
            /* Write file name */
            (*write1)("\r\n",2);        /* Write newline sequence */
            return;                     /* Skip rest of file */
        }
        cbfile += (long)(endbuf - bufptr[bufi]);
        /* Increment count of bytes in file */
        bufi ^= 1;                      /* Switch buffers */
    }
}


void
usage(
      char *errmes
      )
{
    static const char szUsage[] =
    {
        "-? - print this message\n"
        "-B - match pattern if at beginning of line\n"
        "-E - match pattern if at end of line\n"
        "-L - treat search strings literally (fgrep)\n"
        "-O - print seek offset before each matching line\n"
        "-X - treat search strings as regular expressions (grep)\n"
        "-l - print only file name if file contains match\n"
        "-n - print line number before each matching line\n"
        "-z - print matching lines in MSC error message format\n"
        "-v - print only lines not containing a match\n"
        "-x - print lines that match exactly (-BE)\n"
        "-y - treat upper and lower case as equivalent\n"
        "-e - treat next argument literally as a search string\n"
        "-f - read search strings from file named by next argument (- = stdin)\n"
        "-i - read file list from file named by next argument (- = stdin)\n"
        "White space separates search strings unless the argument is prefixed\n"
        "with -e, e.g., 'qgrep \"all out\" x.y' means find either \"all\" or\n"
        "\"out\" in x.y, while 'qgrep -e \"all out\" x.y' means find \"all out\".\n"
    };

    if (errmes != NULL)
        fprintf(stderr,"%s: %s\n", program, errmes);
    /* Print error message */
    fprintf(stderr,"usage: %s [-?BELOXlnzvxy][-e string][-f file][-i file][strings][files]\n", program);
    /* Print command line format */
    if (errmes == NULL) {                  /* If verbose message wanted */
        fputs(szUsage, stderr);
    }
    exit(2);                            /* Error exit */
}

char *
rmpath(
       char *name
       )
{
    char                *cp;            /* Char pointer */

    if (name[0] != '\0' && name[1] == ':') name += 2;
    /* Skip drive spec if any */
    cp = name;                          /* Point to start */
    while (*name != '\0') {                /* While not at end */
        ++name;                         /* Skip to next character */
        if (name[-1] == '/' || name[-1] == '\\') cp = name;
        /* Point past path separator */
    }
    return(cp);                         /* Return pointer to name */
}


int
__cdecl
main(
    int argc,
    char **argv
    )
{
    char                *cp;

    HANDLE              fd;
    DWORD               dwTmp;

    FILE                *fi;
    int                 i;
    int                 j;
    char                *inpfile = NULL;
    char                *strfile = NULL;
    unsigned long       tstart, tend;   /* Start time */
    char                filnam[FILNAMLEN];

    tstart = clock();                   /* Get start time */

    ConvertAppToOem( argc, argv );
    asyncio = pmode = 1;                /* Do asynchronous I/O */

    program = rmpath(argv[0]);          /* Set program name */
    memset(td1,1,TRTABLEN);             /* Set up TD1 for startup */
    flags = 0;
    for (i = 1; i < argc && strchr("/-",argv[i][0]) != NULL; ++i) {
        if (argv[i][1] == '\0' ||
            strchr("?BELNOSXdlntvxyz",argv[i][1]) == NULL) break;
        /* Break if unrecognized switch */
        for (cp = &argv[i][1]; *cp != '\0'; ++cp) {
            switch (*cp) {
                case '?':
                    usage(NULL);          /* Verbose usage message */

                case 'B':
                    flags |= BEGLINE;
                    break;

                case 'E':
                    flags |= ENDLINE;
                    break;

                case 'L':
                    addstr = addstring;   /* Treat strings literally */
                    break;

                case 'N':
                    grep = grepnull;
                    break;

                case 'O':
                    flags |= SEEKOFF;
                    break;

                case 'S':
                    asyncio = 0;          /* Force synchronous I/O */
                    break;

                case 'X':
                    addstr = addexpr;     /* Add expression to list */
                    break;

                case 'd':
                    flags |= DEBUG;
                    break;

                case 'l':
                    flags |= NAMEONLY;
                    break;

                case 'n':
                    flags |= LINENOS;
                    break;

                case 'z':
                    flags |= ZLINENOS | LINENOS;
                    break;

                case 't':
                    flags |= TIMER;
                    break;

                case 'v':
                    grep = grepvbuffer;
                    break;

                case 'x':
                    flags |= BEGLINE | ENDLINE;
                    break;

                case 'y':
                    casesen = 0;
                    break;

                default:
                    fprintf(stderr,"%s: -%c ignored\n",program,*cp);
                    break;
            }
        }
    }
    for (; i < argc && argv[i][0] == '-'; ++i) {
        if (argv[i][2] == '\0') {          /* No multi-character switches */
            switch (argv[i][1]) {
                case 'e':               /* Explicit string (no separators) */
                    if (++i == argc) usage("Argument missing after -e");
                    /* Argument missing after -e */
                    cp = argv[i];         /* Point to string */
                    addstrings( cp, cp + strlen(cp), "" );
                    /* Add string "as is" */
                    continue;

                case 'F':
                    flags |= DOQUOTES;    /* Handle quoted patterns in file */
                case 'f':               /* Patterns in file */
                case 'i':               /* Names of files to search in file */
                    if (i == argc - 1) usage("Argument missing after switch");
                    /* Argument missing */
                    if (argv[i++][1] == 'i') inpfile = argv[i];
                    else strfile = argv[i];
                    continue;
            }
        }
        fprintf(stderr,"%s: %s ignored\n",program,argv[i]);
    }
    if (i == argc && strcnt == 0 && strfile == NULL) usage("Bad command line");
    /* Usage message if arg error */

    if (asyncio) {                         /* Initialize semaphores and threads */
        if ( !( readdone = CreateEvent( NULL, TRUE, TRUE,NULL ) ) ||
             !( readpending = CreateEvent( NULL, TRUE, FALSE,NULL ) ) ||
             !( writedone = CreateEvent( NULL, TRUE, TRUE,NULL ) ) ||
             !( writepending = CreateEvent( NULL, TRUE, FALSE,NULL ) ) ) {
            error("Semaphore creation error");
        }
        if ((CreateThread( NULL,
                           STKLEN,
                           (LPTHREAD_START_ROUTINE)thread2,
                           NULL,
                           0,
                           (LPDWORD)&dwTmp)
             == NULL)
            ||
            (CreateThread( NULL,
                           STKLEN,
                           (LPTHREAD_START_ROUTINE)thread3,
                           NULL,
                           0,
                           (LPDWORD)&dwTmp)
             == NULL)) {
            error("Thread creation error");
        }
        /* Die if thread creation fails */
    }
    _setmode(_fileno(stdout),O_BINARY);   /* No linefeed translation on output */

    bufptr[0][-1] = bufptr[1][-1] = '\n';
    /* Mark beginnings with newline */

    if (_isatty(_fileno(stdout))) {          /* If stdout is a device */
        write1 = write1nobuf;           /* Use unbuffered output */
        flush1 = flush1nobuf;
    }

    if (strfile != NULL) {                 /* If strings from file */
        if (strcmp(strfile,"-") != 0) {    /* If strings not from std. input */
            if ( ( fd = CreateFile( strfile, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL ) ) == (HANDLE)-1 ) {                         /* If open fails */
                fprintf(stderr,"%s: Cannot read strings from %s\n",
                        program,strfile);     /* Print message */
                exit(2);                /* Die */
            }
        } else {
            fd = GetStdHandle( STD_INPUT_HANDLE );     /* Else use std. input */
        }
        qgrep( addstrings, "\r\n", fd );/* Do the work */
        if ( fd != GetStdHandle( STD_INPUT_HANDLE ) ) {
            CloseHandle( fd );          /* Close strings file */
        }
    }
    else if (strcnt == 0) {                /* Else if strings on command line */
        cp = argv[i++];                 /* Set pointer to strings */
        addstrings(cp,cp + strlen(cp)," \t");
        /* Add strings to list */
    }
    if (strcnt == 0) error("No search strings");
    /* Die if no strings */
    if (addstr != addexpr) {               /* If not using expressions */
        memset(td1,(int)(cchmin + 1),TRTABLEN);/* Initialize table */
        find = findlist;                /* Assume finding many */
        if ((j = enumstrings()) != strcnt)
            fprintf(stderr,"String count error (%d != %d)\n",j,strcnt);
        /* Enumerate strings and verify count */
        if (flags & DEBUG) {               /* If debugging output wanted */
            fprintf(stderr,"%u bytes wasted in heap\n",waste);
            /* Print storage waste */
            assert(chmin <= chmax);     /* Must have some entries */
            fprintf(stderr,
                    "chmin = %u, chmax = %u, cchmin = %u\n",chmin,chmax,cchmin);
            /* Print range info */
            for (j = (int)chmin; j <= (int)chmax; ++j) {                         /* Loop to print TD1 table */
                if ( td1[j] <= (char)cchmin ) {    /* If not maximum shift */
                    if (isascii(j) && isprint(j))
                        fprintf(stderr,"'%c'=%2u  ",j,td1[j]);
                    /* Show literally if printable */
                    else fprintf(stderr,"\\%02x=%2u  ",j,td1[j]);
                    /* Else show hex value */
                }
            }
            fprintf(stderr,"\n");
        }
        if (strcnt == 1 && casesen)
            find = findone;             /* Find one case-sensitive string */
    } else if (find == NULL) {
        find = findexpr;                /* Else find expressions */
    }
    if (inpfile != NULL) {                 /* If file list from file */
        flags |= SHOWNAME;              /* Always show name of file */
        if (strcmp(inpfile,"-") != 0) {    /* If name is not "-" */
            if ((fi = fopen(inpfile,"r")) == NULL) {                         /* If open fails */
                fprintf(stderr,"%s: Cannot read file list from %s\n",
                        program,inpfile);     /* Error message */
                exit(2);                /* Error exit */
            }
        } else fi = stdin;                /* Else read file list from stdin */
        while (fgets(filnam,FILNAMLEN,fi) != NULL) {                             /* While there are names */
            filnam[strcspn(filnam,"\r\n")] = '\0';
            /* Null-terminate the name */
            if ((fd = openfile(filnam)) == (HANDLE)-1) {
                continue;               /* Skip file if it cannot be opened */
            }
            qgrep(grep,filnam,fd);      /* Do the work */
            CloseHandle( fd );
        }
        if (fi != stdin) fclose(fi);     /* Close the list file */
    } else if (i == argc) {
        flags &= ~(NAMEONLY | SHOWNAME);
        qgrep( grep, NULL, GetStdHandle( STD_INPUT_HANDLE ) );
    }
    if (argc > i + 1) flags |= SHOWNAME;
    for (; i < argc; ++i) {
        _strlwr(argv[i]);
        if ((fd = openfile(argv[i])) == (HANDLE)-1) {
            continue;
        }
        qgrep(grep,argv[i],fd);
        CloseHandle( fd );
    }
    (*flush1)();
    if ( flags & TIMER ) {                 /* If timing wanted */
        tend = clock();
        tstart = tend - tstart;     /* Get time in milliseconds */
        fprintf(stderr,"%lu.%03lu seconds\n", ( tstart / CLK_TCK ), ( tstart % CLK_TCK ) );
        /* Print total elapsed time */
    }

    return( status );
}


char *findsub();     /* Findlist() worker */
char *findsubi();    /* Findlist() worker */


char *(*flworker[])() =
{             /* Table of workers */
    findsubi,
    findsub
};


char *
strnupr(
        char *pch,
        int cch
        )
{
    while (cch-- > 0) {                 /* Convert string to upper case */
        if (isascii(pch[cch]))
            pch[cch] = (char)toupper(pch[cch]);
    }
    return(pch);
}


/*
 *  This is an implementation of the QuickSearch algorith described
 *  by Daniel M. Sunday in the August 1990 issue of CACM.  The TD1
 *  table is computed before this routine is called.
 */

char *
findone(
        unsigned char *buffer,
        char *bufend
        )
{
    if ((bufend -= targetlen - 1) <= buffer)
        return((char *) 0);             /* Fail if buffer too small */
    while (buffer < bufend) {           /* While space remains */
        int cch;                        /* Character count */
        register char *pch1;            /* Char pointer */
        register char *pch2;            /* Char pointer */

        pch1 = target;                  /* Point at pattern */
        pch2 = buffer;                  /* Point at buffer */
        for (cch = targetlen; cch > 0; --cch) {
            /* Loop to try match */
            if (*pch1++ != *pch2++)
                break;                  /* Exit loop on mismatch */
        }
        if (cch == 0)
            return(buffer);             /* Return pointer to match */
        buffer += td1[buffer[targetlen]];
        /* Skip ahead */
    }
    return((char *) 0);                 /* No match */
}


size_t
preveol(
        char *s
        )
{
    register char       *cp;            /* Char pointer */

    cp = s + 1;                         /* Initialize pointer */
    while (*--cp != '\n') ;              /* Find previous end-of-line */
    return((size_t)(s - cp));                     /* Return distance to match */
}


int
countlines(
           char *start,
           char *finish
           )
{
    register int        count;          /* Line count */

    for (count = 0; start < finish; ) {                                 /* Loop to count lines */
        if (*start++ == '\n') ++count;   /* Increment count if linefeed found */
    }
    return(count);                      /* Return count */
}


char *
findlist(
         unsigned char *buffer,
         char *bufend
         )
{
    char                *match;         /* Pointer to matching string */
    char                endbyte;        /* First byte past end */

    endbyte = *bufend;                  /* Save byte */
    *bufend = '\177';                   /* Mark end of buffer */
    match = (*flworker[casesen])(buffer,bufend);
    /* Call worker */
    *bufend = endbyte;                  /* Restore end of buffer */
    return(match);                      /* Return matching string */
}


char *
findsub(
        unsigned char *buffer,
        char *bufend
        )
{
    register char       *cp;            /* Char pointer */
    STRINGNODE          *s;             /* String node pointer */
    int                 i;              /* Index */

    if ((bufend -= cchmin - 1) < buffer)
        return((char *) 0);             /* Compute effective buffer length */

    while (buffer < bufend) {              /* Loop to find match */
        if ((i = transtab[*buffer]) != 0) {                             /* If valid first character */
            if ((s = stringlist[i]) == 0)
                return(buffer);         /* Check for 1-byte match */
            for (cp = buffer + 1; ; ) {    /* Loop to search list */
                if ((i = memcmp(cp,s_text(s),s->s_must)) == 0) {                     /* If portions match */
                    cp += s->s_must;    /* Skip matching portion */
                    if ((s = s->s_suf) == 0)
                        return(buffer); /* Return match if end of list */
                    continue;           /* Else continue */
                }
                if (i < 0 || (s = s->s_alt) == 0)
                    break;              /* Break if not in this list */
            }
        }
        buffer += td1[buffer[cchmin]];  /* Shift as much as possible */
    }
    return((char *) 0);                 /* No match */
}


char *
findsubi(
         unsigned char *buffer,
         char *bufend
         )
{
    register char       *cp;            /* Char pointer */
    STRINGNODE          *s;             /* String node pointer */
    int                 i;              /* Index */

    if ((bufend -= cchmin - 1) < buffer)
        return((char *) 0);             /* Compute effective buffer length */
    while (buffer < bufend) {              /* Loop to find match */
        if ((i = transtab[*buffer]) != 0) {                             /* If valid first character */
            if ((s = stringlist[i]) == 0)
                return(buffer);         /* Check for 1-byte match */
            for (cp = buffer + 1; ; ) {    /* Loop to search list */
                if ((i = _memicmp(cp,s_text(s),s->s_must)) == 0) {                     /* If portions match */
                    cp += s->s_must;    /* Skip matching portion */
                    if ((s = s->s_suf) == 0)
                        return(buffer); /* Return match if end of list */
                    continue;           /* And continue */
                }
                if (i < 0 || (s = s->s_alt) == 0)
                    break;              /* Break if not in this list */
            }
        }
        buffer += td1[buffer[cchmin]];  /* Shift as much as possible */
    }
    return((char *) 0);                 /* No match */
}


size_t
strnspn(
        char *s,
        char *t,
        size_t n
        )
{
    char                *s1;            /* String pointer */
    char                *t1;            /* String pointer */

    for (s1 = s; n-- != 0; ++s1) {         /* While not at end of s */
        for (t1 = t; *t1 != '\0'; ++t1) {  /* While not at end of t */
            if (*s1 == *t1) break;       /* Break if match found */
        }
        if (*t1 == '\0') break;          /* Break if no match found */
    }
    return((size_t)(s1 - s));                     /* Return length */
}


size_t
strncspn(
         char *s,
         char *t,
         size_t n
         )
{
    char                *s1;            /* String pointer */
    char                *t1;            /* String pointer */

    for (s1 = s; n-- != 0; ++s1) {         /* While not at end of s */
        for (t1 = t; *t1 != '\0'; ++t1) {  /* While not at end of t */
            if (*s1 == *t1)
                return((size_t)(s1 - s));
            /* Return if match found */
        }
    }
    return((size_t)(s1 - s));                     /* Return length */
}


void
matchstrings(
             char *s1,
             char *s2,
             int len,
             size_t *nmatched,
             int *leg
             )
{
    register char  *cp;            /* Char pointer */
    register int (__cdecl *cmp)(const char*,const char*, size_t);       /* Comparison function pointer */

    cmp = casesen? strncmp: _strnicmp;
    /* Set pointer */
    if ((*leg = (*cmp)(s1,s2,len)) != 0) { /* If strings don't match */
        for (cp = s1; (*cmp)(cp,s2++,1) == 0; ++cp)
            ;
        /* Find mismatch */
        *nmatched = (size_t)(cp - s1);            /* Return number matched */
    } else
        *nmatched = len;               /* Else all matched */
}