home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / gnu / grep-2.0-src.lha / src / amiga / grep-2.0 / grep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-23  |  17.1 KB  |  827 lines
  1. /* grep.c - main driver file for grep.
  2.    Copyright (C) 1992 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18.    Written July 1992 by Mike Haertel.  */
  19.  
  20. #include <errno.h>
  21. #include <stdio.h>
  22.  
  23. #ifndef errno
  24. extern int errno;
  25. #endif
  26.  
  27. #ifdef STDC_HEADERS
  28. #include <stdlib.h>
  29. #else
  30. #include <sys/types.h>
  31. extern char *malloc(), *realloc();
  32. extern void free();
  33. #endif
  34.  
  35. #if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
  36. #include <string.h>
  37. #ifdef NEED_MEMORY_H
  38. #include <memory.h>
  39. #endif
  40. #else
  41. #include <strings.h>
  42. #ifdef __STDC__
  43. extern void *memchr(void *, int, size_t);
  44. #else
  45. extern char *memchr();
  46. #endif
  47. #define strrchr rindex
  48. #endif
  49.  
  50. #ifdef HAVE_UNISTD_H
  51. #include <sys/types.h>
  52. #include <fcntl.h>
  53. #include <unistd.h>
  54. #else
  55. #define O_RDONLY 0
  56. extern int open(), read(), close();
  57. #endif
  58.  
  59. #include "getpagesize.h"
  60. #include "grep.h"
  61.  
  62. #undef MAX
  63. #define MAX(A,B) ((A) > (B) ? (A) : (B))
  64.  
  65. /* Provide missing ANSI features if necessary. */
  66.  
  67. #ifndef HAVE_STRERROR
  68. extern int sys_nerr;
  69. extern char *sys_errlist[];
  70. #define strerror(E) ((E) < sys_nerr ? sys_errlist[(E)] : "bogus error number")
  71. #endif
  72.  
  73. #ifndef HAVE_MEMCHR
  74. #ifdef __STDC__
  75. #define VOID void
  76. #else
  77. #define VOID char
  78. #endif
  79. VOID *
  80. memchr(vp, c, n)
  81.      VOID *vp;
  82.      int c;
  83.      size_t n;
  84. {
  85.   unsigned char *p;
  86.  
  87.   for (p = (unsigned char *) vp; n--; ++p)
  88.     if (*p == c)
  89.       return (VOID *) p;
  90.   return 0;
  91. }
  92. #endif
  93.     
  94. /* Define flags declared in grep.h. */
  95. char *matcher;
  96. int match_icase;
  97. int match_words;
  98. int match_lines;
  99.  
  100. /* Functions we'll use to search. */
  101. static void (*compile)();
  102. static char *(*execute)();
  103.  
  104. /* For error messages. */
  105. static char *prog;
  106. static char *filename;
  107. static int errseen;
  108.  
  109. /* Print a message and possibly an error string.  Remember
  110.    that something awful happened. */
  111. static void
  112. error(mesg, errnum)
  113. #ifdef __STDC__
  114.      const
  115. #endif
  116.      char *mesg;
  117.      int errnum;
  118. {
  119.   if (errnum)
  120.     fprintf(stderr, "%s: %s: %s\n", prog, mesg, strerror(errnum));
  121.   else
  122.     fprintf(stderr, "%s: %s\n", prog, mesg);
  123.   errseen = 1;
  124. }
  125.  
  126. /* Like error(), but die horribly after printing. */
  127. void
  128. fatal(mesg, errnum)
  129. #ifdef __STDC__
  130.      const
  131. #endif
  132.      char *mesg;
  133.      int errnum;
  134. {
  135.   error(mesg, errnum);
  136.   exit(2);
  137. }
  138.  
  139. /* Interface to handle errors and fix library lossage. */
  140. char *
  141. xmalloc(size)
  142.      size_t size;
  143. {
  144.   char *result;
  145.  
  146.   result = malloc(size);
  147.   if (size && !result)
  148.     fatal("memory exhausted", 0);
  149.   return result;
  150. }
  151.  
  152. /* Interface to handle errors and fix some library lossage. */
  153. char *
  154. xrealloc(ptr, size)
  155.      char *ptr;
  156.      size_t size;
  157. {
  158.   char *result;
  159.  
  160.   if (ptr)
  161.     result = realloc(ptr, size);
  162.   else
  163.     result = malloc(size);
  164.   if (size && !result)
  165.     fatal("memory exhausted", 0);
  166.   return result;
  167. }
  168.  
  169. #if !defined(HAVE_VALLOC)
  170. #define valloc malloc
  171. #else
  172. #ifdef __STDC__
  173. extern void *valloc(size_t);
  174. #else
  175. extern char *valloc();
  176. #endif
  177. #endif
  178.  
  179. /* Hairy buffering mechanism for grep.  The intent is to keep
  180.    all reads aligned on a page boundary and multiples of the
  181.    page size. */
  182.  
  183. static char *buffer;        /* Base of buffer. */
  184. static size_t bufsalloc;    /* Allocated size of buffer save region. */
  185. static size_t bufalloc;        /* Total buffer size. */
  186. static int bufdesc;        /* File descriptor. */
  187. static char *bufbeg;        /* Beginning of user-visible stuff. */
  188. static char *buflim;        /* Limit of user-visible stuff. */
  189.  
  190. #if defined(HAVE_WORKING_MMAP)
  191. #include <sys/types.h>
  192. #include <sys/stat.h>
  193. #include <sys/mman.h>
  194.  
  195. static int bufmapped;        /* True for ordinary files. */
  196. static struct stat bufstat;    /* From fstat(). */
  197. static off_t bufoffset;        /* What read() normally remembers. */
  198. #endif
  199.  
  200. /* Reset the buffer for a new file.  Initialize
  201.    on the first time through. */
  202. void
  203. reset(fd)
  204.      int fd;
  205. {
  206.   static int initialized;
  207.  
  208.   if (!initialized)
  209.     {
  210.       initialized = 1;
  211. #ifndef BUFSALLOC
  212.       bufsalloc = MAX(8192, getpagesize());
  213. #else
  214.       bufsalloc = BUFSALLOC;
  215. #endif
  216.       bufalloc = 5 * bufsalloc;
  217.       /* The 1 byte of overflow is a kludge for dfaexec(), which
  218.      inserts a sentinel newline at the end of the buffer
  219.      being searched.  There's gotta be a better way... */
  220.       buffer = valloc(bufalloc + 1);
  221.       if (!buffer)
  222.     fatal("memory exhausted", 0);
  223.       bufbeg = buffer;
  224.       buflim = buffer;
  225.     }
  226.   bufdesc = fd;
  227. #if defined(HAVE_WORKING_MMAP)
  228.   if (fstat(fd, &bufstat) < 0 || !S_ISREG(bufstat.st_mode))
  229.     bufmapped = 0;
  230.   else
  231.     {
  232.       bufmapped = 1;
  233.       bufoffset = lseek(fd, 0, 1);
  234.     }
  235. #endif
  236. }
  237.  
  238. /* Read new stuff into the buffer, saving the specified
  239.    amount of old stuff.  When we're done, 'bufbeg' points
  240.    to the beginning of the buffer contents, and 'buflim'
  241.    points just after the end.  Return count of new stuff. */
  242. static int
  243. fillbuf(save)
  244.      size_t save;
  245. {
  246.   char *nbuffer, *dp, *sp;
  247.   int cc;
  248. #if defined(HAVE_WORKING_MMAP)
  249.   caddr_t maddr;
  250. #endif
  251.   static int pagesize;
  252.  
  253.   if (pagesize == 0 && (pagesize = getpagesize()) == 0)
  254.     abort();
  255.  
  256.   if (save > bufsalloc)
  257.     {
  258.       while (save > bufsalloc)
  259.     bufsalloc *= 2;
  260.       bufalloc = 5 * bufsalloc;
  261.       nbuffer = valloc(bufalloc + 1);
  262.       if (!nbuffer)
  263.     fatal("memory exhausted", 0);
  264.     }
  265.   else
  266.     nbuffer = buffer;
  267.  
  268.   sp = buflim - save;
  269.   dp = nbuffer + bufsalloc - save;
  270.   bufbeg = dp;
  271.   while (save--)
  272.     *dp++ = *sp++;
  273.  
  274.   /* We may have allocated a new, larger buffer.  Since
  275.      there is no portable vfree(), we just have to forget
  276.      about the old one.  Sorry. */
  277.   buffer = nbuffer;
  278.  
  279. #if defined(HAVE_WORKING_MMAP)
  280.   if (bufmapped && bufoffset % pagesize == 0
  281.       && bufstat.st_size - bufoffset >= bufalloc - bufsalloc)
  282.     {
  283.       maddr = buffer + bufsalloc;
  284.       maddr = mmap(maddr, bufalloc - bufsalloc, PROT_READ | PROT_WRITE,
  285.            MAP_PRIVATE | MAP_FIXED, bufdesc, bufoffset);
  286.       if (maddr == (caddr_t) -1)
  287.     {
  288.       fprintf(stderr, "%s: warning: %s: %s\n", filename,
  289.           strerror(errno));
  290.       goto tryread;
  291.     }
  292. #if 0
  293.       /* You might thing this (or MADV_WILLNEED) would help,
  294.      but it doesn't, at least not on a Sun running 4.1.
  295.      In fact, it actually slows us down about 30%! */
  296.       madvise(maddr, bufalloc - bufsalloc, MADV_SEQUENTIAL);
  297. #endif
  298.       cc = bufalloc - bufsalloc;
  299.       bufoffset += cc;
  300.     }
  301.   else
  302.     {
  303.     tryread:
  304.       /* We come here when we're not going to use mmap() any more.
  305.      Note that we need to synchronize the file offset the
  306.      first time through. */
  307.       if (bufmapped)
  308.     {
  309.       bufmapped = 0;
  310.       lseek(bufdesc, bufoffset, 0);
  311.     }
  312.       cc = read(bufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
  313.     }
  314. #else
  315.   cc = read(bufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
  316. #endif
  317.   if (cc > 0)
  318.     buflim = buffer + bufsalloc + cc;
  319.   else
  320.     buflim = buffer + bufsalloc;
  321.   return cc;
  322. }
  323.  
  324. /* Flags controlling the style of output. */
  325. static int out_quiet;        /* Suppress all normal output. */
  326. static int out_invert;        /* Print nonmatching stuff. */
  327. static int out_file;        /* Print filenames. */
  328. static int out_line;        /* Print line numbers. */
  329. static int out_byte;        /* Print byte offsets. */
  330. static int out_before;        /* Lines of leading context. */
  331. static int out_after;        /* Lines of trailing context. */
  332.  
  333. /* Internal variables to keep track of byte count, context, etc. */
  334. static size_t totalcc;        /* Total character count before bufbeg. */
  335. static char *lastnl;        /* Pointer after last newline counted. */
  336. static char *lastout;        /* Pointer after last character output;
  337.                    NULL if no character has been output
  338.                    or if it's conceptually before bufbeg. */
  339. static size_t totalnl;        /* Total newline count before lastnl. */
  340. static int pending;        /* Pending lines of output. */
  341.  
  342. static void
  343. nlscan(lim)
  344.      char *lim;
  345. {
  346.   char *beg;
  347.  
  348.   for (beg = lastnl; beg < lim; ++beg)
  349.     if (*beg == '\n')
  350.       ++totalnl;
  351.   lastnl = beg;
  352. }
  353.  
  354. static void
  355. prline(beg, lim, sep)
  356.      char *beg;
  357.      char *lim;
  358.      char sep;
  359. {
  360.   if (out_file)
  361.     printf("%s%c", filename, sep);
  362.   if (out_line)
  363.     {
  364.       nlscan(beg);
  365.       printf("%d%c", ++totalnl, sep);
  366.       lastnl = lim;
  367.     }
  368.   if (out_byte)
  369.     printf("%lu%c", totalcc + (beg - bufbeg), sep);
  370.   fwrite(beg, 1, lim - beg, stdout);
  371.   if (ferror(stdout))
  372.     error("writing output", errno);
  373.   lastout = lim;
  374. }
  375.  
  376. /* Print pending lines of trailing context prior to LIM. */
  377. static void
  378. prpending(lim)
  379.      char *lim;
  380. {
  381.   char *nl;
  382.  
  383.   if (!lastout)
  384.     lastout = bufbeg;
  385.   while (pending > 0 && lastout < lim)
  386.     {
  387.       --pending;
  388.       if ((nl = memchr(lastout, '\n', lim - lastout)) != 0)
  389.     ++nl;
  390.       else
  391.     nl = lim;
  392.       prline(lastout, nl, '-');
  393.     }
  394. }
  395.  
  396. /* Print the lines between BEG and LIM.  Deal with context crap.
  397.    If NLINESP is non-null, store a count of lines between BEG and LIM. */
  398. static void
  399. prtext(beg, lim, nlinesp)
  400.      char *beg;
  401.      char *lim;
  402.      int *nlinesp;
  403. {
  404.   static int used;        /* avoid printing "--" before any output */
  405.   char *bp, *p, *nl;
  406.   int i, n;
  407.  
  408.   if (!out_quiet && pending > 0)
  409.     prpending(beg);
  410.  
  411.   p = beg;
  412.  
  413.   if (!out_quiet)
  414.     {
  415.       /* Deal with leading context crap. */
  416.  
  417.       bp = lastout ? lastout : bufbeg;
  418.       for (i = 0; i < out_before; ++i)
  419.     if (p > bp)
  420.       do
  421.         --p;
  422.       while (p > bp && p[-1] != '\n');
  423.  
  424.       /* We only print the "--" separator if our output is
  425.      discontiguous from the last output in the file. */
  426.       if ((out_before || out_after) && used && p != lastout)
  427.     puts("--");
  428.  
  429.       while (p < beg)
  430.     {
  431.       nl = memchr(p, '\n', beg - p);
  432.       prline(p, nl + 1, '-');
  433.       p = nl + 1;
  434.     }
  435.     }
  436.  
  437.   if (nlinesp)
  438.     {
  439.       /* Caller wants a line count. */
  440.       for (n = 0; p < lim; ++n)
  441.     {
  442.       if ((nl = memchr(p, '\n', lim - p)) != 0)
  443.         ++nl;
  444.       else
  445.         nl = lim;
  446.       if (!out_quiet)
  447.         prline(p, nl, ':');
  448.       p = nl;
  449.     }
  450.       *nlinesp = n;
  451.     }
  452.   else
  453.     if (!out_quiet)
  454.       prline(beg, lim, ':');
  455.  
  456.   pending = out_after;
  457.   used = 1;
  458. }
  459.  
  460. /* Scan the specified portion of the buffer, matching lines (or
  461.    between matching lines if OUT_INVERT is true).  Return a count of
  462.    lines printed. */
  463. static int
  464. grepbuf(beg, lim)
  465.      char *beg;
  466.      char *lim;
  467. {
  468.   int nlines, n;
  469.   register char *p, *b;
  470.   char *endp;
  471.  
  472.   nlines = 0;
  473.   p = beg;
  474.   while ((b = (*execute)(p, lim - p, &endp)) != 0)
  475.     {
  476.       /* Avoid matching the empty line at the end of the buffer. */
  477.       if (b == lim && ((b > beg && b[-1] == '\n') || b == beg))
  478.     break;
  479.       if (!out_invert)
  480.     {
  481.       prtext(b, endp, (int *) 0);
  482.       nlines += 1;
  483.     }
  484.       else if (p < b)
  485.     {
  486.       prtext(p, b, &n);
  487.       nlines += n;
  488.     }
  489.       p = endp;
  490.     }
  491.   if (out_invert && p < lim)
  492.     {
  493.       prtext(p, lim, &n);
  494.       nlines += n;
  495.     }
  496.   return nlines;
  497. }
  498.  
  499. /* Search a given file.  Return a count of lines printed. */
  500. static int
  501. grep(fd)
  502.      int fd;
  503. {
  504.   int nlines, i;
  505.   size_t residue, save;
  506.   char *beg, *lim;
  507.  
  508.   reset(fd);
  509.  
  510.   totalcc = 0;
  511.   lastout = 0;
  512.   totalnl = 0;
  513.   pending = 0;
  514.  
  515.   nlines = 0;
  516.   residue = 0;
  517.   save = 0;
  518.  
  519.   for (;;)
  520.     {
  521.       if (fillbuf(save) < 0)
  522.     {
  523.       error(filename, errno);
  524.       return nlines;
  525.     }
  526.       lastnl = bufbeg;
  527.       if (lastout)
  528.     lastout = bufbeg;
  529.       if (buflim - bufbeg == save)
  530.     break;
  531.       beg = bufbeg + save - residue;
  532.       for (lim = buflim; lim > beg && lim[-1] != '\n'; --lim)
  533.     ;
  534.       residue = buflim - lim;
  535.       if (beg < lim)
  536.     {
  537.       nlines += grepbuf(beg, lim);
  538.       if (pending)
  539.         prpending(lim);
  540.     }
  541.       i = 0;
  542.       beg = lim;
  543.       while (i < out_before && beg > bufbeg && beg != lastout)
  544.     {
  545.       ++i;
  546.       do
  547.         --beg;
  548.       while (beg > bufbeg && beg[-1] != '\n');
  549.     }
  550.       if (beg != lastout)
  551.     lastout = 0;
  552.       save = residue + lim - beg;
  553.       totalcc += buflim - bufbeg - save;
  554.       if (out_line)
  555.     nlscan(beg);
  556.     }
  557.   if (residue)
  558.     {
  559.       nlines += grepbuf(bufbeg + save - residue, buflim);
  560.       if (pending)
  561.     prpending(buflim);
  562.     }
  563.   return nlines;
  564. }
  565.  
  566. static char version[] = "GNU grep version 2.0";
  567.  
  568. #define USAGE \
  569.   "usage: %s [-[[AB] ]<num>] [-[CEFGVchilnqsvwx]] [-[ef]] <expr> [<files...>]\n"
  570.  
  571. static void
  572. usage()
  573. {
  574.   fprintf(stderr, USAGE, prog);
  575.   exit(2);
  576. }
  577.  
  578. /* Go through the matchers vector and look for the specified matcher.
  579.    If we find it, install it in compile and execute, and return 1.  */
  580. int
  581. setmatcher(name)
  582.      char *name;
  583. {
  584.   int i;
  585.  
  586.   for (i = 0; matchers[i].name; ++i)
  587.     if (strcmp(name, matchers[i].name) == 0)
  588.       {
  589.     compile = matchers[i].compile;
  590.     execute = matchers[i].execute;
  591.     return 1;
  592.       }
  593.   return 0;
  594. }  
  595.  
  596. int
  597. main(argc, argv)
  598.      int argc;
  599.      char *argv[];
  600. {
  601.   char *keys;
  602.   size_t keycc, oldcc, keyalloc;
  603.   int keyfound, count_matches, no_filenames, list_files, suppress_errors;
  604.   int opt, cc, desc, count, status;
  605.   FILE *fp;
  606.   extern char *optarg;
  607.   extern int optind;
  608.  
  609.   prog = argv[0];
  610.   if (prog && strrchr(prog, '/'))
  611.     prog = strrchr(prog, '/') + 1;
  612.  
  613.   keys = NULL;
  614.   keycc = 0;
  615.   keyfound = 0;
  616.   count_matches = 0;
  617.   no_filenames = 0;
  618.   list_files = 0;
  619.   suppress_errors = 0;
  620.   matcher = NULL;
  621.  
  622.   while ((opt = getopt(argc, argv, "0123456789A:B:CEFGVX:bce:f:hiLlnqsvwxy"))
  623.      != EOF)
  624.     switch (opt)
  625.       {
  626.       case '0':
  627.       case '1':
  628.       case '2':
  629.       case '3':
  630.       case '4':
  631.       case '5':
  632.       case '6':
  633.       case '7':
  634.       case '8':
  635.       case '9':
  636.     out_before = 10 * out_before + opt - '0';
  637.     out_after = 10 * out_after + opt - '0';
  638.     break;
  639.       case 'A':
  640.     out_after = atoi(optarg);
  641.     if (out_after < 0)
  642.       usage();
  643.     break;
  644.       case 'B':
  645.     out_before = atoi(optarg);
  646.     if (out_before < 0)
  647.       usage();
  648.     break;
  649.       case 'C':
  650.     out_before = out_after = 2;
  651.     break;
  652.       case 'E':
  653.     if (matcher && strcmp(matcher, "egrep") != 0)
  654.       fatal("you may specify only one of -E, -F, or -G", 0);
  655.     matcher = "posix-egrep";
  656.     break;
  657.       case 'F':
  658.     if (matcher && strcmp(matcher, "fgrep") != 0)
  659.       fatal("you may specify only one of -E, -F, or -G", 0);;
  660.     matcher = "fgrep";
  661.     break;
  662.       case 'G':
  663.     if (matcher && strcmp(matcher, "grep") != 0)
  664.       fatal("you may specify only one of -E, -F, or -G", 0);
  665.     matcher = "grep";
  666.     break;
  667.       case 'V':
  668.     fprintf(stderr, "%s\n", version);
  669.     break;
  670.       case 'X':
  671.     if (matcher)
  672.       fatal("matcher already specified", 0);
  673.     matcher = optarg;
  674.     break;
  675.       case 'b':
  676.     out_byte = 1;
  677.     break;
  678.       case 'c':
  679.     out_quiet = 1;
  680.     count_matches = 1;
  681.     break;
  682.       case 'e':
  683.     cc = strlen(optarg);
  684.     keys = xrealloc(keys, keycc + cc + 1);
  685.     if (keyfound)
  686.       keys[keycc++] = '\n';
  687.     strcpy(&keys[keycc], optarg);
  688.     keycc += cc;
  689.     keyfound = 1;
  690.     break;
  691.       case 'f':
  692.     fp = strcmp(optarg, "-") != 0 ? fopen(optarg, "r") : stdin;
  693.     if (!fp)
  694.       fatal(optarg, errno);
  695.     for (keyalloc = 1; keyalloc <= keycc; keyalloc *= 2)
  696.       ;
  697.     keys = xrealloc(keys, keyalloc);
  698.     oldcc = keycc;
  699.     if (keyfound)
  700.       keys[keycc++] = '\n';
  701.     while (!feof(fp)
  702.            && (cc = fread(keys + keycc, 1, keyalloc - keycc, fp)) > 0)
  703.       {
  704.         keycc += cc;
  705.         if (keycc == keyalloc)
  706.           keys = xrealloc(keys, keyalloc *= 2);
  707.       }
  708.     if (fp != stdin)
  709.       fclose(fp);
  710.     /* Nuke the final newline to avoid matching a null string. */
  711.     if (keycc - oldcc > 0 && keys[keycc - 1] == '\n')
  712.       --keycc;
  713.     keyfound = 1;
  714.     break;
  715.       case 'h':
  716.     no_filenames = 1;
  717.     break;
  718.       case 'i':
  719.       case 'y':            /* For old-timers . . . */
  720.     match_icase = 1;
  721.     break;
  722.       case 'L':
  723.     /* Like -l, except list files that don't contain matches.
  724.        Inspired by the same option in Hume's gre. */
  725.     out_quiet = 1;
  726.     list_files = -1;
  727.     break;
  728.       case 'l':
  729.     out_quiet = 1;
  730.     list_files = 1;
  731.     break;
  732.       case 'n':
  733.     out_line = 1;
  734.     break;
  735.       case 'q':
  736.     out_quiet = 1;
  737.     break;
  738.       case 's':
  739.     suppress_errors = 1;
  740.     break;
  741.       case 'v':
  742.     out_invert = 1;
  743.     break;
  744.       case 'w':
  745.     match_words = 1;
  746.     break;
  747.       case 'x':
  748.     match_lines = 1;
  749.     break;
  750.       default:
  751.     usage();
  752.     break;
  753.       }
  754.  
  755.   if (!keyfound)
  756.     if (optind < argc)
  757.       {
  758.     keys = argv[optind++];
  759.     keycc = strlen(keys);
  760.       }
  761.     else
  762.       usage();
  763.  
  764.   if (!matcher)
  765.     matcher = prog;
  766.  
  767.   if (!setmatcher(matcher) && !setmatcher("default"))
  768.     abort();
  769.  
  770.   (*compile)(keys, keycc);
  771.  
  772.   if (argc - optind > 1 && !no_filenames)
  773.     out_file = 1;
  774.  
  775.   status = 1;
  776.  
  777.   if (optind < argc)
  778.     while (optind < argc)
  779.       {
  780.     desc = strcmp(argv[optind], "-") ? open(argv[optind], O_RDONLY) : 0;
  781.     if (desc < 0)
  782.       {
  783.         if (!suppress_errors)
  784.           error(argv[optind], errno);
  785.       }
  786.     else
  787.       {
  788.         filename = desc == 0 ? "(standard input)" : argv[optind];
  789.         count = grep(desc);
  790.         if (count_matches)
  791.           {
  792.         if (out_file)
  793.           printf("%s:", filename);
  794.         printf("%d\n", count);
  795.           }
  796.         if (count)
  797.           {
  798.         status = 0;
  799.         if (list_files == 1)
  800.           printf("%s\n", filename);
  801.           }
  802.         else if (list_files == -1)
  803.           printf("%s\n", filename);
  804.       }
  805.     if (desc != 0)
  806.       close(desc);
  807.     ++optind;
  808.       }
  809.   else
  810.     {
  811.       filename = "(standard input)";
  812.       count = grep(0);
  813.       if (count_matches)
  814.     printf("%d\n", count);
  815.       if (count)
  816.     {
  817.       status = 0;
  818.       if (list_files == 1)
  819.         printf("(standard input)\n");
  820.     }
  821.       else if (list_files == -1)
  822.     printf("(standard input)\n");
  823.     }
  824.  
  825.   exit(errseen ? 2 : status);
  826. }
  827.