Oakland CPM Archive/oakcpm.iso/cpm/bdsc-3/fp.cq/FP.C

C/C++ Source or Header | 1985-02-10 | 5.3 KB | 186 lines

/*        Find Pattern
 *
 *    This is a program which prints out all lines in a file with a
 * given pattern.  It can be conditionally compiled for either CP/M or
 * Unix.  In either case, it is invoked by:
 *
 *        fp <pattern> <file(s)>
 *
 *    The <file(s)> specification can use normal file widcards, as
 * defined by wildexp in CP/M and the shell in Unix.
 *    The <pattern> is a string of characters, some of which have special
 * meanings:
 *
 *        <char> - any character not listed below matches exactly that
 *             character.
 *        ? - matches any single character.
 *        * - matches zero or more of any character.
 *        [...] - matches one of any of the characters included between
 *            the brackets; character ranges can also be indicated
 *            by <char>-<char>.  E.g., [a-z0-9] will match any
 *            letter or digit.
 *        [-...] - matches one of any of the characters not included
 *             between the brackets.
 *
 *    Also, backslash (\) can be used to quote characters (i.e., keep them
 * from being interpreted specially).
 *
 *    To compile and load the program, make sure that one of UNIX or CPM
 * is defined (not both!) in fp.c, and that you have pat.h and pat.c (and
 * wildexp.crl).  On CP/M, then do:
 *
 *        cc1 pat.c
 *        cc1 fp.c
 *        clink fp pat wildexp
 *
 *    On Unix, then do:
 *
 *        cc -O -o fp fp.c pat.c
 *
 *    Note: On Unix, fp runs about three times slower than grep, so it's
 * not clear why you'd want to use it.  This is probably because I use
 * recursion.  Maybe I'll do a non-recursive version later, but this way
 * is much simpler.
 *
 *
 *    Initial coding 8/18/82 by Harry R. Chesley.
 *
 *
 *    Copyright 1982 by Harry R. Chesley.
 *    Unlimited permission granted for non-profit use only.
 */

#include "pat.h"

/* UNIX - defined for use on Unix.
 * CPM - defined for use on CP/M (with BDS-C).
 *
 * MAXBSZ - max size of text buffer (big to minimize IO); should be a multiple
 *        of 128 for CPM, but doesn't really have to be.  One more char is
 *        allocated so that a zero byte can be appended when printing
 *        strings.
 * MAXPSZ - max size of pattern string.
 */

#define UNIX
/*#define CPM*/

#define MAXBSZ 10240+1
#define MAXPSZ 100

/*    main()
 *
 *    Function: Invoked by "fp <pattern> <files>".  Prints every line in
 * each file containing the pattern.
 *
 *    Algorithm: Use srchpat() to locate each subsequent line to be output.
 *
 *    Comments: The only tricky things here are: (1) The search pattern is
 * surrounded with "*"s because srchpat() will only do exact matches;
 * inserting the "*"s makes it match the pattern anywhere on the line.  And
 * (2) when we find outselves at the end of a buffer, we read in a new buffer
 * of text, but keep any partial lines to concatenate with the next buffer
 * load.
 *    I use puts() in the CP/M version because BDS-C printf breaks on long
 * lines.  I don't use it in the Unix version because Unix puts() appends
 * newlines to the string.
 */

main(argc,argv)

int argc;
char *argv[];

{
    int fd;            /* File descriptor. */
    char tbuf[MAXBSZ];    /* Input buffer. */
    char pat[MAXPSZ];    /* Search pattern. */
    char *pptr;        /* Pattern string pointer. */
    char *aptr;        /* Argv pattern pointer. */
    char *nptr;        /* New pointer (in copying partials). */
    char *tptr;        /* Text pointer (while searching). */
    char *retstr;        /* Srchpat() return value. */
    char *eosret;        /* EOS pointer return from srchpat(). */
    char ctmp;        /* Temp storage. */
    int sz, osz;        /* Bytes remaining sizes. */

#ifdef CPM
    /* Fake command name. */
    argv[0] = "FP";
#endif

    /* Verify proper calling procedure: */
    if (argc < 3) {
        printf("Usage: %s <pattern> <file(s)>\n",argv[0]);
        exit(1);
    };

    /* Copy search pattern, prepend and postpend "*". */
    pptr = pat;
    *pptr++ = '*';
    for (aptr = argv[1]; *aptr != 0; *pptr++ = *aptr++);
    *pptr++ = '*';
    *pptr = 0;

    /* Compile search pattern; normal EOL, ignore case. */
    comppat(pat,'\n',TRUE);

#ifdef CPM
    /* Remove search pattern from argv, and expand file names. */
    argv[1] = "NOARG";
    wildexp(&argc, &argv);
#endif

    /* Go thru the files one by one. */
    argc--; argv++; argc--; argv++;    /* Skip command name and pattern. */
    while (argc-- > 0) {
        if ((fd = open(argv[0],0)) == -1) {
            printf("Bad file name: %s!\n",argv[0]);
            argv++;
            continue;
        };

        /* Read & write, read & write, ... */
        osz = 0;
#ifdef UNIX
        while ((sz = read(fd,tbuf+osz,(MAXBSZ-1)-osz)) > 0) {
#endif
#ifdef CPM
        while ((sz = 128*read(fd,tbuf+osz,((MAXBSZ-1)-osz)/128)) > 0){
#endif
            osz += sz;
            tptr = tbuf;

            /* While there's something worth printing. */
            while ((retstr = srchpat(tptr,osz,&eosret)) != 0) {
                ctmp = *eosret;
                *eosret = 0;
#ifdef UNIX
                printf("%s: %s",argv[0],retstr);
#endif
#ifdef CPM
                puts(argv[0]); puts(": "); puts(retstr);
#endif
                *eosret = ctmp;
                osz -= eosret - tptr;
                tptr = eosret;
            };

            /* Find partial line at end. */
            tptr += osz-1;
            for (sz = 0; sz != osz; sz++) {
                if (*tptr == '\n') break;
                tptr--;
            };

            /* Copy partial. */
            tptr++;
            osz = sz;
            for (nptr = tbuf; sz != 0; sz--) *nptr++ = *tptr++;
        };

        close(fd);
        argv++;
    };
}