home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 236_01 / sgrep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-05  |  20.1 KB  |  829 lines
  1. /*
  2.     HEADER:        CUG236;
  3.     TITLE:        SGREP Text Pattern Replacer (McKe86);
  4.     DATE:        05/17/1987;
  5.     DESCRIPTION:    "Is a modified version of the CUG 152 grep program,
  6.             with the added features of string substitution,
  7.             multiple pattern search, case sensitivity, and scanning
  8.             option.";
  9.     VERSION:    1.0;
  10.     KEYWORDS:    Text filter;
  11.     FILENAME:    SGREP.C;
  12.     SEE-ALSO:    SGREP.DOC;
  13.     COMPILERS:    vanilla;
  14.     AUTHORS:    J. McKeon;
  15. */
  16.  
  17. /*
  18.  *
  19.  * The    information  in     this  document     is  subject  to  change
  20.  * without  notice  and     should not be construed as a commitment
  21.  * by Digital Equipment Corporation or by DECUS.
  22.  *
  23.  * Neither Digital Equipment Corporation, DECUS, nor the authors
  24.  * assume any responsibility for the use or reliability of  this
  25.  * document or the described software.
  26.  *
  27.  *    Copyright (C) 1980, DECUS
  28.  *
  29.  * General permission to copy or modify, but not for profit,  is
  30.  * hereby  granted,  provided that the above copyright notice is
  31.  * included and reference made to  the    fact  that  reproduction
  32.  * privileges were granted by DECUS.
  33.  *
  34.  */
  35.  
  36. #include "stdio.h"
  37.  
  38. /*
  39.  * grep.
  40.  *
  41.  * Runs on the Decus compiler or on vms.
  42.  * Converted for BDS compiler (under CP/M-80), 20-Jan-83, by Chris Kern.
  43.  * Converted to IBM PC with CI-C86 C Compiler June 1983 by David N. Smith
  44.  * On vms, define as:
  45.  *    grep :== "$disk:[account]grep"       (native)
  46.  *    grep :== "$disk:[account]grep grep"    (Decus)
  47.  *
  48.  * sgrep.
  49.  *
  50.  * Addition of string substitution capability,
  51.  * multiple pattern search, upper-lower case option, scanning options,
  52.  * and name changed to sgrep, April 1986 by James J. McKeon.
  53.  * Runs on IBM PC or compatibles using ECO C88 compiler.
  54.  *
  55.  * For help type "sgrep ?".  See below for more information.
  56.  *
  57.  * May 1987, William C. Colley, III -- Fixed bug in usage of function fgets()
  58.  * in function compat().  Added several notes about portability to various
  59.  * compilers.  Fixed a glitch in case STAR of function pmatch() that crashed
  60.  * the program when compiled under MSDOS large model.  The glitch occurred
  61.  * when a pointer was (deliberately) run backward past the beginning of an
  62.  * array of char.  The array was exactly on a paragraph boundary, so the
  63.  * pointer decremented from 0x0e5d0000 to 0x0e5dffff instead of to 0x0e5cffff
  64.  * as expected.  A pointer comparison then turned out bogus data and the
  65.  * program went into an infinite loop.  The moral of this story is:  Don't
  66.  * play fast and loose with pointers if you want portability.
  67.  */
  68.  
  69. /*
  70.  * Portability Note:  The AZTEC C compilers handle the binary/text file
  71.  * dichotomy differently from most other compilers.  Uncomment the following
  72.  * pair of #defines if you are running AZTEC C:
  73.  */
  74.  
  75. /*
  76. #define getc(f)        agetc(f)
  77. #define putc(c,f)    aputc(c,f)
  78. */
  79.  
  80. /*
  81.  * Portability Note:  8-bit systems often don't have header file ctype.h.
  82.  * If your system doesn't have it, uncomment the #define NO_CTYPE_H.
  83.  */
  84.  
  85. /*
  86. #define NO_CTYPE_H
  87. */
  88.  
  89. #ifdef    NO_CTYPE_H
  90. int isalpha(), isalnum(), isdigit(), tolower();
  91. #else
  92. #include <ctype.h>
  93. #endif
  94.  
  95. char    *documentation[] = {
  96. "Sgrep searches a file for a given pattern and substitutes a pattern.",
  97. "If no substitution is required, the command sgrep -myn corresponds",
  98. "to grep -n and will match only. Output is to the screen and may be",
  99. "re-directed using \">\" at the DOS level. Execute by",
  100. "  sgrep [flags] pattern-file input-file",
  101. "",
  102. "Flags are single characters preceeded by '-':",
  103. "   -c      Only a count of matching lines is printed",
  104. "   -m      Match patterns only, no substitutions.",
  105. "   -n      Each line is preceeded by its line number",
  106. "   -v      Only print non-matching lines",
  107. "   -y      Upper and lower case match.",
  108. "",
  109. 0 };
  110.  
  111. char    *patdoc[] = {
  112. "Each match pattern is on a separate line followed by its substitute",
  113. "pattern, if any, also on a separate line.",
  114.  
  115. " MATCH PATTERNS",
  116. "The regular_expression defines the pattern to search for.  Upper and",
  117. "lower-case are regarded as different unless -y option is used.",
  118. "x      An ordinary character (not mentioned below) matches that character.",
  119. "'\\'    The backslash quotes any character.  \"\\$\" matches a dollar-sign.",
  120. "'$'    Matches beginning or end of line.",
  121. "'.'    A period matches any character except \"new-line\".",
  122. "':a'   A colon matches a class of characters described by the following",
  123. "':d'     character.  \":a\" matches any alphabetic, \":d\" matches digits,",
  124. "':n'     \":n\" matches alphanumerics, \": \" matches spaces, tabs, and",
  125. "': '     other control characters except new-line.",
  126. "'*'    An expression followed by an asterisk matches zero or more",
  127. "       occurrances of that expression: \"fo*\" matches \"f\", \"fo\"",
  128. "       \"foo\", etc.",
  129. "'+'    An expression followed by a plus sign matches one or more",
  130. "       occurrances of that expression: \"fo+\" matches \"fo\", etc.",
  131. "'-'    An expression followed by a minus sign optionally matches",
  132. "       the expression.",
  133. "'[]'   A string enclosed in square brackets matches any character in",
  134. "       that string, but no others.  If the first character in the",
  135. "       string is a circumflex, the expression matches any character",
  136. "       except \"new-line\" and the characters in the string.  For",
  137. "       example, \"[xyz]\" matches \"xx\" and \"zyx\", while \"[^xyz]\"",
  138. "       matches \"abc\" but not \"axb\".  A range of characters may be",
  139. "       specified by two characters separated by \"-\".  Note that,",
  140. "       [a-z] matches alphabetics, while [z-a] never matches.",
  141. "The concatenation of regular expressions is a regular expression.",
  142.  
  143. " Scanning options:",
  144. "The default scanning option is match all occurences of the pattern.",
  145. "'@'    at the beginning of the pattern, is equivalent to",
  146. "       \"$: *\", meaning match first non-whitespace pattern.",
  147. "'@e'   at the end of a pattern means that if a match is",
  148. "       found (and a substitution made), end all pattern search",
  149. "       on current line.",
  150. "'@r'   at the end of a pattern means that after a match",
  151. "       (and substitution), rescan line until no match occurs.",
  152.  
  153. " SUBSTITUTE PATTERNS ",
  154. "The only control character for substitute patterns is \"?\".",
  155. "Any other character represents itself. Only the characters ? and",
  156. " \\ itself need to be quoted.",
  157.  
  158. "'?n'   where n is a non-zero digit, indicates the position where",
  159. "       the nth wildcard string is to be placed.",
  160. "A wildcard string is any string which is not completely fixed,",
  161. "both as to the characters and number of characters in the string.",
  162. 0};
  163.  
  164. #define LMAX    100
  165. #define PMAX    2000
  166. #define NPATMAX 100
  167.  
  168. #define CHR    1
  169. #define SCOP    2
  170. #define BEOL    3
  171. #define ANY    4
  172. #define CLASS    5
  173. #define NCLASS    6
  174. #define STAR    7
  175. #define PLUS    8
  176. #define MINUS    9
  177. #define ALPHA    10
  178. #define DIGIT    11
  179. #define NALPHA    12
  180. #define PUNCT    13
  181. #define RANGE    14
  182. #define ENDPAT    15
  183. #define lowopt(x) yflag?tolower(x):x
  184.  
  185. int    cflag;
  186. int    mflag;
  187. int    nflag;
  188. int    vflag;
  189. int    yflag;
  190.  
  191. int    debug    =    0;       /* Set for debug code      */
  192.  
  193. char    *pp, *psp;
  194.  
  195. #ifndef vms
  196. char    file_name[81];
  197. #endif
  198.  
  199. char    lbuf[LMAX], slbuf[LMAX];
  200. char    pbuf[PMAX], spbuf[PMAX];
  201. char    * wldstr[19][2];  /* Location of wildcard strings */
  202. int    nws, npat, rescan, nxtln;
  203. char   *mpp[NPATMAX], *mpsp[NPATMAX];  /* Location of patterns */
  204.  
  205. void exit();
  206. /*******************************************************/
  207.  
  208. int main(argc, argv)
  209. int argc;
  210. char *argv[];
  211. {
  212.    register char   *p;
  213.    register int       c;
  214.    FILE           *f;
  215.    void cant(), compat(), grep(), help(), usage();
  216.  
  217.    if (argc <= 1)
  218.       usage("No arguments");
  219.    if (argc == 2 && argv[1][0] == '?' && argv[1][1] == 0) {
  220.       help(documentation);
  221.       help(patdoc);
  222.       return !0;
  223.       }
  224.       p=argv[argc-1];
  225.       if ((f=fopen(p, "r")) == NULL) cant(p);
  226.       p = argv[1];
  227.       if (*p == '-') {
  228.      ++p;
  229.      while (c = *p++) {
  230.         switch(tolower(c)) {
  231.  
  232.         case 'c':
  233.            ++cflag;
  234.            break;
  235.  
  236.         case 'd':
  237.            ++debug;
  238.            break;
  239.  
  240.         case 'm':
  241.            ++mflag;
  242.            break;
  243.  
  244.         case 'n':
  245.            ++nflag;
  246.            break;
  247.  
  248.         case 'v':
  249.            ++vflag;
  250.            break;
  251.  
  252.         case 'y':
  253.            ++yflag;
  254.            break;
  255.  
  256.         default:
  257.            usage("Unknown flag");
  258.         }
  259.      }
  260.     p=argv[2];
  261.       }
  262.       compat(p);
  263.       grep(f);
  264.       fclose(f);
  265.       return 0;
  266. }
  267.  
  268. /*******************************************************/
  269.  
  270. void cant(s)
  271. char *s;
  272. {
  273.    fprintf(stderr, "%s: cannot open\n", s);
  274. }
  275.  
  276.  
  277. /*******************************************************/
  278.  
  279. void help(hp)
  280. char **hp;  /* dns added extra '*'  */
  281. /*
  282.  * Give good help
  283.  */
  284. {
  285.    register char   **dp;
  286.  
  287.    for (dp = hp; *dp; dp++)
  288.       printf("%s\n", *dp);
  289. }
  290.  
  291. /*******************************************************/
  292.  
  293. void usage(s)
  294. char *s;
  295. {
  296.    fprintf(stderr, "?SGREP-%s\n", s);
  297.    fprintf(stderr,
  298.   "Usage: sgrep [-mycnv] pattern-file input-file. sgrep ? for help\n");
  299.    exit(1);
  300. }
  301.  
  302. /*******************************************************/
  303.  
  304.  
  305. void compile(source)
  306. char *source;        /* Pattern to compile          */
  307. /*
  308.  * Compile the pattern into global pbuf[]
  309.  */
  310. {
  311.    register char  *s;          /* Source string pointer       */
  312.    register char  *lp;          /* Last pattern pointer       */
  313.    register int      c;          /* Current character       */
  314.    int          o;          /* Temp               */
  315.    char          *spp;          /* Save beginning of pattern */
  316.    char          *cclass();  /* Compile class routine       */
  317.    void badpat(), store();
  318.  
  319.    s = source;
  320.    if (debug)
  321.       printf("Pattern = %s\n", s);
  322.    while (c = *s++) {
  323.       /*
  324.        * STAR, PLUS and MINUS are special.
  325.        */
  326.       if (c == '*' || c == '+' || c == '-') {
  327.      if (pp == pbuf ||
  328.           (o=pp[-1]) == SCOP || o == '\0' ||
  329.           o == BEOL ||
  330.           o == STAR ||
  331.           o == PLUS ||
  332.           o == MINUS)
  333.         badpat("Illegal occurrance op.", source, s);
  334.      store(ENDPAT);
  335.      store(ENDPAT);
  336.      spp = pp;         /* Save pattern end     */
  337.      while (--pp > lp)     /* Move pattern down     */
  338.         *pp = pp[-1];     /* one byte         */
  339.      *pp =     (c == '*') ? STAR :
  340.         (c == '-') ? MINUS : PLUS;
  341.      pp = spp;         /* Restore pattern end     */
  342.      continue;
  343.       }
  344.       /*
  345.        * All the rest.
  346.        */
  347.       lp = pp;           /* Remember start       */
  348.       switch(c) {
  349.  
  350.       case '@':
  351.      if(s-1 == source) {
  352.        store(BEOL);
  353.        store(STAR);
  354.        store(PUNCT);
  355.        store(ENDPAT);
  356.        break;
  357.      } else {
  358.      store(SCOP);
  359.      store(*s++);
  360.      break;
  361.      }
  362.       case '$':
  363.      store(BEOL);
  364.      break;
  365.  
  366.       case '.':
  367.      store(ANY);
  368.      break;
  369.  
  370.       case '[':
  371.      s = cclass(source, s);
  372.      break;
  373.  
  374.       case ':':
  375.      if (*s) {
  376.         switch(c = *s++) {
  377.  
  378.         case 'a':
  379.         case 'A':
  380.            store(ALPHA);
  381.            break;
  382.  
  383.         case 'd':
  384.         case 'D':
  385.            store(DIGIT);
  386.            break;
  387.  
  388.         case 'n':
  389.         case 'N':
  390.            store(NALPHA);
  391.            break;
  392.  
  393.         case ' ':
  394.            store(PUNCT);
  395.            break;
  396.  
  397.         default:
  398.            badpat("Unknown : type", source, s);
  399.  
  400.         }
  401.         break;
  402.      }
  403.      else     badpat("No : type", source, s);
  404.  
  405.       case '\\':
  406.      if (*s)
  407.         c = *s++;
  408.  
  409.       default:
  410.      store(CHR);
  411.      store(lowopt(c));
  412.       }
  413.    }
  414.    pp -= 2;           /* delete linefeed */
  415.    store(ENDPAT);
  416.    store(0);            /* Terminate string        */
  417.    mpp[npat+1] = pp;
  418.    if (debug) {
  419.       for (lp = mpp[npat]; lp < pp;) {
  420.      if ((c = (*lp++ & 0377)) < ' ')
  421.         printf("\\%x ", c);
  422.      else     printf("%c ", c);
  423.     }
  424.     printf("\n");
  425.    }
  426. }
  427.  
  428. /*******************************************************/
  429.  
  430. char *cclass(source, src)
  431. char *source;         /* Pattern start -- for error msg.         */
  432. char *src;         /* Class start          */
  433. /*
  434.  * Compile a class (within [])
  435.  */
  436. {
  437.    register char   *s;          /* Source pointer       */
  438.    register char   *cp;          /* Pattern start       */
  439.    register int       c;          /* Current character */
  440.    int           o;          /* Temp           */
  441.    void badpat(), store();
  442.  
  443.    s = src;
  444.    o = CLASS;
  445.    if (*s == '^') {
  446.       ++s;
  447.       o = NCLASS;
  448.    }
  449.    store(o);
  450.    cp = pp;
  451.    store(0);                  /* Byte count     */
  452.    while ((c = *s++) && c!=']') {
  453.       if (c == '\\') {              /* Store quoted char    */
  454.      if ((c = *s++) == '\0')      /* Gotta get something  */
  455.         badpat("Class terminates badly", source, s);
  456.      else store(lowopt(c));
  457.       }
  458.       else if (c == '-' &&
  459.         (pp - cp) > 1 && *s != ']' && *s != '\0') {
  460.      c = pp[-1];         /* Range start        */
  461.      pp[-1] = RANGE;     /* Range signal    */
  462.      store(c);         /* Re-store start  */
  463.      c = *s++;         /* Get end char and*/
  464.      store(lowopt(c));    /* Store it       */
  465.       }
  466.       else {
  467.      store(lowopt(c));    /* Store normal char */
  468.       }
  469.    }
  470.    if (c != ']')
  471.       badpat("Unterminated class", source, s);
  472.    if ((c = (pp - cp)) >= 256)
  473.       badpat("Class too large", source, s);
  474.    if (c == 0)
  475.       badpat("Empty class", source, s);
  476.    *cp = c;
  477.    return(s);
  478. }
  479.  
  480. /*******************************************************/
  481.  
  482. void store(op)
  483. int op;
  484. {
  485.    void error();
  486.  
  487.    if (pp >= &pbuf[PMAX])
  488.       error("Pattern too complex\n");
  489.    *pp++ = op;
  490. }
  491.  
  492. /*******************************************************/
  493.  
  494. void badpat(message, source, stop)
  495. char  *message;          /* Error message */
  496. char  *source;          /* Pattern start */
  497. char  *stop;          /* Pattern end   */
  498. {
  499.    void error();
  500.  
  501.    fprintf(stderr, "-GREP-E-%s, pattern is\"%s\"\n", message, source);
  502.    fprintf(stderr, "-GREP-E-Stopped at byte %d, '%c'\n",
  503.      stop-source, stop[-1]);
  504.    error("?GREP-E-Bad pattern\n");
  505. }
  506.  
  507. /*******************************************************/
  508.  
  509. void grep(fp)
  510. FILE       *fp;          /* File to process        */
  511. /*
  512.  * Scan the file for the pattern in pbuf[]
  513.  */
  514. {
  515.    register int lno, count, m;
  516.    int    jpat, mm, match();
  517.  
  518.    lno = 0;
  519.    count = 0;
  520.    while (fgets(lbuf, LMAX, fp)) {
  521.     ++lno;
  522.     mm = 0;
  523.     for(jpat=1;jpat<=npat;jpat++){
  524.      m = nxtln = 0;
  525.      do {
  526.        rescan = 0;
  527.        if(match(jpat)) m = 1;
  528.      } while(rescan == 1);
  529.      if(m) mm = 1;
  530.       if(nxtln)
  531.     break;
  532.     }/*jpat*/
  533.     if (!mflag)
  534.       printf("%s", lbuf);
  535.     else if(mm && !vflag || !mm && vflag) {
  536.       if(cflag)
  537.     count++;
  538.       else {
  539.     if(nflag)
  540.       printf("%d\t", lno);
  541.     printf("%s\n", lbuf);
  542.       }
  543.     }
  544.    }/*wh*/
  545.    if (cflag)
  546.       printf("%d\n", count);
  547. }
  548.  
  549. /*******************************************************/
  550.  
  551. int match(jp)
  552. /*
  553.  * Match the current line (in lbuf[]), return 1 if it does.
  554.  */
  555.   int  jp;
  556. {
  557.    register char   *l;          /* Line pointer        */
  558.    char     *s, *pat, *lst;
  559.    int km;
  560.    char *pmatch(), *movs();
  561.    void substit();
  562.  
  563.    km=0;
  564.    pat = mpp[jp];
  565.    l = lst = lbuf;
  566.    while(*l) {
  567.       nws = 0;
  568.       s=pmatch(l,pat);
  569.       if (s){
  570.     if(s < l) break;    /* BOL impossible */
  571.     km = 1;
  572.     if(mflag) break;
  573.     wldstr[0][0]=l;
  574.     wldstr[0][1]=s;
  575.     substit(lst, jp);
  576.     lst = s;
  577.     l = s - 1;
  578.       }
  579.       if(nxtln) break;
  580.       l++;
  581.    }
  582.    if(km && !mflag) {
  583.      substit(lst, 0);
  584.      l = movs(slbuf,slbuf+LMAX,lbuf);
  585.      *l = 0;
  586.    }
  587.    return(km);
  588. }
  589.  
  590. /*******************************************************/
  591.  
  592. char *pmatch(line, pattern)
  593. char           *line;     /* (partial) line to match      */
  594. char           *pattern;  /* (partial) pattern to match   */
  595. {
  596.    register char   *l;          /* Current line pointer          */
  597.    register char   *p;          /* Current pattern pointer      */
  598.    register char   c;          /* Current character          */
  599.    char           *e;          /* End for STAR and PLUS match  */
  600.    int           op;          /* Pattern operation          */
  601.    int           n;          /* Class counter              */
  602.    char           *are;      /* Start of STAR match          */
  603.    int    ows;
  604.    static int wss;          /* Wild string switch */
  605.    void error();
  606.  
  607.    l = line;
  608.    if (debug > 1)
  609.       printf("pmatch(\"%s\")\n", line);
  610.    p = pattern;
  611.    while ((op = *p++) != ENDPAT) {
  612.       if (debug > 1)
  613.      printf("byte[%d] = 0%o, '%c', op = 0%o\n",
  614.            l-line, *l, *l, op);
  615.       switch(op) {
  616.  
  617.       case CHR:
  618.      c = *l++;
  619.      if ((yflag ? tolower(c) : c) != *p++)
  620.         return NULL;
  621.      break;
  622.  
  623.       case SCOP:
  624.      if(*p++ == 'r')
  625.        rescan = 1;
  626.      else
  627.        nxtln = 1;
  628.      break;
  629.  
  630.       case BEOL:
  631.      if((p-1) == pattern && l != lbuf) return(line-1);
  632.      if((p-1) != pattern && *l != '\n') return NULL;
  633.      break;
  634.  
  635.       case ANY:
  636.      if (*l++ == '\n')
  637.         return NULL;
  638.      break;
  639.  
  640.       case DIGIT:
  641.      c = *l++;
  642.      if(!isdigit(c)) return NULL;
  643.      break;
  644.  
  645.       case ALPHA:
  646.      c = *l++;
  647.      if (!isalpha(c)) return NULL;
  648.      break;
  649.  
  650.       case NALPHA:
  651.      c = *l++;
  652.      if (!isalnum(c)) return NULL;
  653.      break;
  654.  
  655.       case PUNCT:
  656.      if ((c = *l++) == '\n' || c > ' ')
  657.         return NULL;
  658.      break;
  659.  
  660.       case CLASS:
  661.       case NCLASS:
  662.      c = *l++;
  663.      if (yflag) c = tolower(c);
  664.      n = *p++ & 0377;
  665.      do {
  666.         if (*p == RANGE) {
  667.            p += 3;
  668.            n -= 2;
  669.            if (c >= p[-2] && c <= p[-1])
  670.           break;
  671.         }
  672.         else {
  673.           if(c == '\n')
  674.         return NULL;
  675.           if (c == *p++) break;
  676.         }
  677.      } while (--n > 1);
  678.       if(op == CLASS && n <= 1) return NULL;
  679.       if(op != CLASS && n > 1) return NULL;
  680.      if (op == CLASS)
  681.         p += n - 2;
  682.      break;
  683.  
  684.       case MINUS:
  685.      e = pmatch(l, p);     /* Look for a match    */
  686.      while (*p++ != ENDPAT); /* Skip over pattern    */
  687.      if (e)             /* Got a match?    */
  688.         l = e;         /* Yes, update string    */
  689.      break;             /* Always succeeds    */
  690.  
  691.       case PLUS:         /* One or more ...    */
  692.      wss=1;             /* wldstr switch on */
  693.      if (!(l = pmatch(l, p))){
  694.         wss=0;
  695.         return NULL;     /* Gotta have a match    */
  696.      }
  697.       case STAR:         /* Zero or more ...    */
  698.      wss = 1;         /* wldstr switch on */
  699.      for (are = l; *l && (e = pmatch(l, p)); l = e);
  700.                  /* Get longest match    */
  701.      wss = 0;
  702.      ows = ++nws;         /* Save wildstring number */
  703.      while (*p++ != ENDPAT); /* Skip over pattern    */
  704.      do {             /* Try to match rest    */
  705.         if (e = pmatch(l, p)){
  706.          wldstr[ows][0]=are - op + 7; /* Subtract 1 if plus */
  707.          wldstr[ows][1]=l;
  708.           return(e);
  709.          }
  710.         nws = ows;
  711.      } while (l-- > are);
  712.      return NULL;         /* Nothing else worked */
  713.  
  714.       default:
  715.      printf("Bad op code %d\n", op);
  716.      error("Cannot happen -- match\n");
  717.       }
  718.       if((wss == 0) && (op >= 4) && (op <= 13)){
  719.     ++nws;
  720.     wldstr[nws][0] = l-1;  /* single character */
  721.     wldstr[nws][1] = l;
  722.     if(op == 9 && e == 0)
  723.       wldstr[nws][0] = l;  /* null string */
  724.       }
  725.   }
  726.    return(l);
  727. }
  728.  
  729. /*******************************************************/
  730.  
  731. void error(s)
  732. char *s;
  733. {
  734.    fprintf(stderr, "%s", s);
  735.    exit(1);
  736. }
  737.  
  738. void compat(patfile)    /* Read in pattern file and compile patterns */
  739. char  *patfile;
  740. {
  741.     FILE  *fp;
  742.     char  *l;
  743.     void cant(), compile(), compsub(), error();
  744.  
  745.     if((fp=fopen(patfile,"r")) == NULL) cant(patfile);
  746.     npat = 0;  mpp[1] = pp = pbuf;  mpsp[1] = psp = spbuf;
  747.     while((l = fgets(slbuf,LMAX,fp)) && *l){
  748.     npat += 1;  compile(slbuf);
  749.     if(!mflag) {
  750.         if (l = fgets(slbuf,PMAX,fp)) compsub();
  751.         else
  752.         error("?GREP-E-Odd number of lines in substitution pattern\n");
  753.     }
  754.     }
  755.     if(debug) printf(" npat = %d \n",npat);
  756.     fclose(fp);
  757. }
  758.  
  759. void compsub()
  760. /* Compile substitute pattern into spbuf */
  761. {
  762. char *l, *p, c;
  763.   if(debug) printf(" Subspat = %s \n",slbuf);
  764.   p = psp;
  765.   for(l=slbuf;*l;l++){
  766.     c = *l;
  767.     switch(c){
  768.     case '?':
  769.       *p++ = 7;
  770.       l++;
  771.       *p++ = (*l - 48);
  772.       break;
  773.     case '\\':
  774.       c = *(++l);
  775.     default:
  776.       *p++ = c;
  777.     }
  778.   }
  779.     p--;     /* delete linefeed */
  780.     *p = 0;
  781.     psp = ++p;
  782.    mpsp[npat+1] = psp;
  783.    if(debug){
  784.     for(l=mpsp[npat];*l;l++){
  785.       if((c = (*l & 0377)) < ' ') printf("\\%x ",c);
  786.       else printf("%c ",c);
  787.     }
  788.     printf("\n");
  789.    }
  790. }
  791.  
  792. char  *movs(l1,l2,p)
  793. /* Move string from l1 to p */
  794. char  *l1, *l2, *p;
  795. {
  796. char  *l;
  797.   for(l = l1; l < l2 && *l; l++)
  798.     *p++ = *l;
  799.   return(p);
  800. }
  801.  
  802. void substit(lb, jpat)    /* construct output record */
  803. char  *lb;
  804. int  jpat;
  805. {
  806. char  *movs(), *p;
  807. static char *sl = slbuf;
  808. int k;
  809.  if(jpat == 0){
  810.   sl =    movs(wldstr[0][1],lbuf+LMAX,sl);
  811.   *sl = 0;
  812.   sl = slbuf;
  813.   return;
  814.  }
  815.   psp = mpsp[jpat];
  816.   sl = movs(lb,wldstr[0][0],sl);
  817.   for(p=psp; *p; p++){
  818.     switch(*p) {
  819.     case 7:
  820.       p++;
  821.       k = *p;
  822.       sl =   movs(wldstr[k][0],wldstr[k][1],sl);
  823.       break;
  824.     default:
  825.       *sl++ = *p;
  826.     }/*sw*/
  827.   }
  828. }
  829.