1 /* $NetBSD: grep.c,v 1.6 2011/04/18 03:48:23 joerg Exp $ */
2 /* $OpenBSD: grep.c,v 1.42 2010/07/02 22:18:03 tedu Exp $ */
3
4 /*-
5 * SPDX-License-Identifier: BSD-2-Clause
6 *
7 * Copyright (c) 1999 James Howard and Dag-Erling Smørgrav
8 * Copyright (C) 2008-2009 Gabor Kovesdan <gabor@FreeBSD.org>
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 #include <sys/stat.h>
35 #include <sys/types.h>
36
37 #include <ctype.h>
38 #include <err.h>
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <getopt.h>
42 #include <limits.h>
43 #include <libgen.h>
44 #include <locale.h>
45 #include <stdbool.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <unistd.h>
50
51 #include "grep.h"
52
53 const char *errstr[] = {
54 "",
55 /* 1*/ "(standard input)",
56 /* 2*/ "unknown %s option",
57 /* 3*/ "usage: %s [-abcDEFGHhIiLlmnOopqRSsUVvwxz] [-A num] [-B num] [-C num]\n",
58 /* 4*/ "\t[-e pattern] [-f file] [--binary-files=value] [--color=when]\n",
59 /* 5*/ "\t[--context=num] [--directories=action] [--label] [--line-buffered]\n",
60 /* 6*/ "\t[--null] [pattern] [file ...]\n",
61 /* 7*/ "Binary file %s matches\n",
62 /* 8*/ "%s (BSD grep, GNU compatible) %s\n",
63 };
64
65 /* Flags passed to regcomp() and regexec() */
66 int cflags = REG_NOSUB | REG_NEWLINE;
67 int eflags = REG_STARTEND;
68
69 bool matchall;
70
71 /* Searching patterns */
72 unsigned int patterns;
73 static unsigned int pattern_sz;
74 struct pat *pattern;
75 regex_t *r_pattern;
76
77 /* Filename exclusion/inclusion patterns */
78 unsigned int fpatterns, dpatterns;
79 static unsigned int fpattern_sz, dpattern_sz;
80 struct epat *dpattern, *fpattern;
81
82 /* For regex errors */
83 char re_error[RE_ERROR_BUF + 1];
84
85 /* Command-line flags */
86 long long Aflag; /* -A x: print x lines trailing each match */
87 long long Bflag; /* -B x: print x lines leading each match */
88 bool Hflag; /* -H: always print file name */
89 bool Lflag; /* -L: only show names of files with no matches */
90 bool bflag; /* -b: show block numbers for each match */
91 bool cflag; /* -c: only show a count of matching lines */
92 bool hflag; /* -h: don't print filename headers */
93 bool iflag; /* -i: ignore case */
94 bool lflag; /* -l: only show names of files with matches */
95 bool mflag; /* -m x: stop reading the files after x matches */
96 long long mcount; /* count for -m */
97 long long mlimit; /* requested value for -m */
98 char fileeol; /* indicator for eol */
99 bool nflag; /* -n: show line numbers in front of matching lines */
100 bool oflag; /* -o: print only matching part */
101 bool qflag; /* -q: quiet mode (don't output anything) */
102 bool sflag; /* -s: silent mode (ignore errors) */
103 bool vflag; /* -v: only show non-matching lines */
104 bool wflag; /* -w: pattern must start and end on word boundaries */
105 bool xflag; /* -x: pattern must match entire line */
106 bool lbflag; /* --line-buffered */
107 bool nullflag; /* --null */
108 char *label; /* --label */
109 const char *color; /* --color */
110 int grepbehave = GREP_BASIC; /* -EFG: type of the regex */
111 int binbehave = BINFILE_BIN; /* -aIU: handling of binary files */
112 int filebehave = FILE_STDIO;
113 int devbehave = DEV_READ; /* -D: handling of devices */
114 int dirbehave = DIR_READ; /* -dRr: handling of directories */
115 int linkbehave = LINK_READ; /* -OpS: handling of symlinks */
116
117 bool dexclude, dinclude; /* --exclude-dir and --include-dir */
118 bool fexclude, finclude; /* --exclude and --include */
119
120 enum {
121 BIN_OPT = CHAR_MAX + 1,
122 COLOR_OPT,
123 HELP_OPT,
124 MMAP_OPT,
125 LINEBUF_OPT,
126 LABEL_OPT,
127 NULL_OPT,
128 R_EXCLUDE_OPT,
129 R_INCLUDE_OPT,
130 R_DEXCLUDE_OPT,
131 R_DINCLUDE_OPT
132 };
133
134 static inline const char *init_color(const char *);
135
136 /* Housekeeping */
137 bool file_err; /* file reading error */
138
139 /*
140 * Prints usage information and returns 2.
141 */
142 static void
usage(void)143 usage(void)
144 {
145 fprintf(stderr, errstr[3], getprogname());
146 fprintf(stderr, "%s", errstr[4]);
147 fprintf(stderr, "%s", errstr[5]);
148 fprintf(stderr, "%s", errstr[6]);
149 exit(2);
150 }
151
152 static const char *optstr = "0123456789A:B:C:D:EFGHILOSRUVabcd:e:f:hilm:nopqrsuvwxyz";
153
154 static const struct option long_options[] =
155 {
156 {"binary-files", required_argument, NULL, BIN_OPT},
157 {"help", no_argument, NULL, HELP_OPT},
158 {"mmap", no_argument, NULL, MMAP_OPT},
159 {"line-buffered", no_argument, NULL, LINEBUF_OPT},
160 {"label", required_argument, NULL, LABEL_OPT},
161 {"null", no_argument, NULL, NULL_OPT},
162 {"color", optional_argument, NULL, COLOR_OPT},
163 {"colour", optional_argument, NULL, COLOR_OPT},
164 {"exclude", required_argument, NULL, R_EXCLUDE_OPT},
165 {"include", required_argument, NULL, R_INCLUDE_OPT},
166 {"exclude-dir", required_argument, NULL, R_DEXCLUDE_OPT},
167 {"include-dir", required_argument, NULL, R_DINCLUDE_OPT},
168 {"after-context", required_argument, NULL, 'A'},
169 {"text", no_argument, NULL, 'a'},
170 {"before-context", required_argument, NULL, 'B'},
171 {"byte-offset", no_argument, NULL, 'b'},
172 {"context", optional_argument, NULL, 'C'},
173 {"count", no_argument, NULL, 'c'},
174 {"devices", required_argument, NULL, 'D'},
175 {"directories", required_argument, NULL, 'd'},
176 {"extended-regexp", no_argument, NULL, 'E'},
177 {"regexp", required_argument, NULL, 'e'},
178 {"fixed-strings", no_argument, NULL, 'F'},
179 {"file", required_argument, NULL, 'f'},
180 {"basic-regexp", no_argument, NULL, 'G'},
181 {"no-filename", no_argument, NULL, 'h'},
182 {"with-filename", no_argument, NULL, 'H'},
183 {"ignore-case", no_argument, NULL, 'i'},
184 {"files-with-matches", no_argument, NULL, 'l'},
185 {"files-without-match", no_argument, NULL, 'L'},
186 {"max-count", required_argument, NULL, 'm'},
187 {"line-number", no_argument, NULL, 'n'},
188 {"only-matching", no_argument, NULL, 'o'},
189 {"quiet", no_argument, NULL, 'q'},
190 {"silent", no_argument, NULL, 'q'},
191 {"recursive", no_argument, NULL, 'r'},
192 {"no-messages", no_argument, NULL, 's'},
193 {"binary", no_argument, NULL, 'U'},
194 {"unix-byte-offsets", no_argument, NULL, 'u'},
195 {"invert-match", no_argument, NULL, 'v'},
196 {"version", no_argument, NULL, 'V'},
197 {"word-regexp", no_argument, NULL, 'w'},
198 {"line-regexp", no_argument, NULL, 'x'},
199 {"null-data", no_argument, NULL, 'z'},
200 {NULL, no_argument, NULL, 0}
201 };
202
203 /*
204 * Adds a searching pattern to the internal array.
205 */
206 static void
add_pattern(char * pat,size_t len)207 add_pattern(char *pat, size_t len)
208 {
209
210 /* Check if we can do a shortcut */
211 if (len == 0) {
212 matchall = true;
213 return;
214 }
215 /* Increase size if necessary */
216 if (patterns == pattern_sz) {
217 pattern_sz *= 2;
218 pattern = grep_realloc(pattern, ++pattern_sz *
219 sizeof(struct pat));
220 }
221 if (len > 0 && pat[len - 1] == '\n')
222 --len;
223 /* pat may not be NUL-terminated */
224 pattern[patterns].pat = grep_malloc(len + 1);
225 memcpy(pattern[patterns].pat, pat, len);
226 pattern[patterns].len = len;
227 pattern[patterns].pat[len] = '\0';
228 ++patterns;
229 }
230
231 /*
232 * Adds a file include/exclude pattern to the internal array.
233 */
234 static void
add_fpattern(const char * pat,int mode)235 add_fpattern(const char *pat, int mode)
236 {
237
238 /* Increase size if necessary */
239 if (fpatterns == fpattern_sz) {
240 fpattern_sz *= 2;
241 fpattern = grep_realloc(fpattern, ++fpattern_sz *
242 sizeof(struct epat));
243 }
244 fpattern[fpatterns].pat = grep_strdup(pat);
245 fpattern[fpatterns].mode = mode;
246 ++fpatterns;
247 }
248
249 /*
250 * Adds a directory include/exclude pattern to the internal array.
251 */
252 static void
add_dpattern(const char * pat,int mode)253 add_dpattern(const char *pat, int mode)
254 {
255
256 /* Increase size if necessary */
257 if (dpatterns == dpattern_sz) {
258 dpattern_sz *= 2;
259 dpattern = grep_realloc(dpattern, ++dpattern_sz *
260 sizeof(struct epat));
261 }
262 dpattern[dpatterns].pat = grep_strdup(pat);
263 dpattern[dpatterns].mode = mode;
264 ++dpatterns;
265 }
266
267 /*
268 * Reads searching patterns from a file and adds them with add_pattern().
269 */
270 static void
read_patterns(const char * fn)271 read_patterns(const char *fn)
272 {
273 struct stat st;
274 FILE *f;
275 char *line;
276 size_t len;
277 ssize_t rlen;
278
279 if (strcmp(fn, "-") == 0)
280 f = stdin;
281 else if ((f = fopen(fn, "r")) == NULL)
282 err(2, "%s", fn);
283 if ((fstat(fileno(f), &st) == -1) || (S_ISDIR(st.st_mode))) {
284 fclose(f);
285 return;
286 }
287 len = 0;
288 line = NULL;
289 while ((rlen = getline(&line, &len, f)) != -1) {
290 if (line[0] == '\0')
291 continue;
292 add_pattern(line, line[0] == '\n' ? 0 : (size_t)rlen);
293 }
294
295 free(line);
296 if (ferror(f))
297 err(2, "%s", fn);
298 if (strcmp(fn, "-") != 0)
299 fclose(f);
300 }
301
302 static inline const char *
init_color(const char * d)303 init_color(const char *d)
304 {
305 char *c;
306
307 c = getenv("GREP_COLOR");
308 return (c != NULL && c[0] != '\0' ? c : d);
309 }
310
311 int
main(int argc,char * argv[])312 main(int argc, char *argv[])
313 {
314 char **aargv, **eargv, *eopts;
315 char *ep;
316 const char *pn;
317 long long l;
318 unsigned int aargc, eargc, i;
319 int c, lastc, needpattern, newarg, prevoptind;
320 bool matched;
321
322 setlocale(LC_ALL, "");
323
324 /*
325 * Check how we've bene invoked to determine the behavior we should
326 * exhibit. In this way we can have all the functionalities in one
327 * binary without the need of scripting and using ugly hacks.
328 */
329 pn = getprogname();
330 switch (pn[0]) {
331 case 'e':
332 grepbehave = GREP_EXTENDED;
333 break;
334 case 'f':
335 grepbehave = GREP_FIXED;
336 break;
337 case 'r':
338 dirbehave = DIR_RECURSE;
339 Hflag = true;
340 break;
341 }
342
343 lastc = '\0';
344 newarg = 1;
345 prevoptind = 1;
346 needpattern = 1;
347 fileeol = '\n';
348
349 eopts = getenv("GREP_OPTIONS");
350
351 /* support for extra arguments in GREP_OPTIONS */
352 eargc = 0;
353 if (eopts != NULL && eopts[0] != '\0') {
354 char *str;
355
356 /* make an estimation of how many extra arguments we have */
357 for (unsigned int j = 0; j < strlen(eopts); j++)
358 if (eopts[j] == ' ')
359 eargc++;
360
361 eargv = (char **)grep_malloc(sizeof(char *) * (eargc + 1));
362
363 eargc = 0;
364 /* parse extra arguments */
365 while ((str = strsep(&eopts, " ")) != NULL)
366 if (str[0] != '\0')
367 eargv[eargc++] = grep_strdup(str);
368
369 aargv = (char **)grep_calloc(eargc + argc + 1,
370 sizeof(char *));
371
372 aargv[0] = argv[0];
373 for (i = 0; i < eargc; i++)
374 aargv[i + 1] = eargv[i];
375 for (int j = 1; j < argc; j++, i++)
376 aargv[i + 1] = argv[j];
377
378 aargc = eargc + argc;
379 } else {
380 aargv = argv;
381 aargc = argc;
382 }
383
384 while (((c = getopt_long(aargc, aargv, optstr, long_options, NULL)) !=
385 -1)) {
386 switch (c) {
387 case '0': case '1': case '2': case '3': case '4':
388 case '5': case '6': case '7': case '8': case '9':
389 if (newarg || !isdigit(lastc))
390 Aflag = 0;
391 else if (Aflag > LLONG_MAX / 10 - 1) {
392 errno = ERANGE;
393 err(2, NULL);
394 }
395
396 Aflag = Bflag = (Aflag * 10) + (c - '0');
397 break;
398 case 'C':
399 if (optarg == NULL) {
400 Aflag = Bflag = 2;
401 break;
402 }
403 /* FALLTHROUGH */
404 case 'A':
405 /* FALLTHROUGH */
406 case 'B':
407 errno = 0;
408 l = strtoll(optarg, &ep, 10);
409 if (errno == ERANGE || errno == EINVAL)
410 err(2, NULL);
411 else if (ep[0] != '\0') {
412 errno = EINVAL;
413 err(2, NULL);
414 } else if (l < 0) {
415 errno = EINVAL;
416 err(2, "context argument must be non-negative");
417 }
418
419 if (c == 'A')
420 Aflag = l;
421 else if (c == 'B')
422 Bflag = l;
423 else
424 Aflag = Bflag = l;
425 break;
426 case 'a':
427 binbehave = BINFILE_TEXT;
428 break;
429 case 'b':
430 bflag = true;
431 break;
432 case 'c':
433 cflag = true;
434 break;
435 case 'D':
436 if (strcasecmp(optarg, "skip") == 0)
437 devbehave = DEV_SKIP;
438 else if (strcasecmp(optarg, "read") == 0)
439 devbehave = DEV_READ;
440 else
441 errx(2, errstr[2], "--devices");
442 break;
443 case 'd':
444 if (strcasecmp("recurse", optarg) == 0) {
445 Hflag = true;
446 dirbehave = DIR_RECURSE;
447 } else if (strcasecmp("skip", optarg) == 0)
448 dirbehave = DIR_SKIP;
449 else if (strcasecmp("read", optarg) == 0)
450 dirbehave = DIR_READ;
451 else
452 errx(2, errstr[2], "--directories");
453 break;
454 case 'E':
455 grepbehave = GREP_EXTENDED;
456 break;
457 case 'e':
458 {
459 char *token;
460 char *string = optarg;
461
462 while ((token = strsep(&string, "\n")) != NULL)
463 add_pattern(token, strlen(token));
464 }
465 needpattern = 0;
466 break;
467 case 'F':
468 grepbehave = GREP_FIXED;
469 break;
470 case 'f':
471 read_patterns(optarg);
472 needpattern = 0;
473 break;
474 case 'G':
475 grepbehave = GREP_BASIC;
476 break;
477 case 'H':
478 Hflag = true;
479 break;
480 case 'h':
481 Hflag = false;
482 hflag = true;
483 break;
484 case 'I':
485 binbehave = BINFILE_SKIP;
486 break;
487 case 'i':
488 case 'y':
489 iflag = true;
490 cflags |= REG_ICASE;
491 break;
492 case 'L':
493 lflag = false;
494 Lflag = true;
495 break;
496 case 'l':
497 Lflag = false;
498 lflag = true;
499 break;
500 case 'm':
501 mflag = true;
502 errno = 0;
503 mlimit = mcount = strtoll(optarg, &ep, 10);
504 if (((errno == ERANGE) && (mcount == LLONG_MAX)) ||
505 ((errno == EINVAL) && (mcount == 0)))
506 err(2, NULL);
507 else if (ep[0] != '\0') {
508 errno = EINVAL;
509 err(2, NULL);
510 }
511 break;
512 case 'n':
513 nflag = true;
514 break;
515 case 'O':
516 linkbehave = LINK_EXPLICIT;
517 break;
518 case 'o':
519 oflag = true;
520 cflags &= ~REG_NOSUB;
521 break;
522 case 'p':
523 linkbehave = LINK_SKIP;
524 break;
525 case 'q':
526 qflag = true;
527 break;
528 case 'S':
529 linkbehave = LINK_READ;
530 break;
531 case 'R':
532 case 'r':
533 dirbehave = DIR_RECURSE;
534 Hflag = true;
535 break;
536 case 's':
537 sflag = true;
538 break;
539 case 'U':
540 binbehave = BINFILE_BIN;
541 break;
542 case 'u':
543 case MMAP_OPT:
544 filebehave = FILE_MMAP;
545 break;
546 case 'V':
547 printf(errstr[8], getprogname(), VERSION);
548 exit(0);
549 case 'v':
550 vflag = true;
551 break;
552 case 'w':
553 wflag = true;
554 cflags &= ~REG_NOSUB;
555 break;
556 case 'x':
557 xflag = true;
558 cflags &= ~REG_NOSUB;
559 break;
560 case 'z':
561 fileeol = '\0';
562 cflags &= ~REG_NEWLINE;
563 break;
564 case BIN_OPT:
565 if (strcasecmp("binary", optarg) == 0)
566 binbehave = BINFILE_BIN;
567 else if (strcasecmp("without-match", optarg) == 0)
568 binbehave = BINFILE_SKIP;
569 else if (strcasecmp("text", optarg) == 0)
570 binbehave = BINFILE_TEXT;
571 else
572 errx(2, errstr[2], "--binary-files");
573 break;
574 case COLOR_OPT:
575 color = NULL;
576 if (optarg == NULL || strcasecmp("auto", optarg) == 0 ||
577 strcasecmp("tty", optarg) == 0 ||
578 strcasecmp("if-tty", optarg) == 0) {
579 char *term;
580
581 term = getenv("TERM");
582 if (isatty(STDOUT_FILENO) && term != NULL &&
583 strcasecmp(term, "dumb") != 0)
584 color = init_color("01;31");
585 } else if (strcasecmp("always", optarg) == 0 ||
586 strcasecmp("yes", optarg) == 0 ||
587 strcasecmp("force", optarg) == 0) {
588 color = init_color("01;31");
589 } else if (strcasecmp("never", optarg) != 0 &&
590 strcasecmp("none", optarg) != 0 &&
591 strcasecmp("no", optarg) != 0)
592 errx(2, errstr[2], "--color");
593 cflags &= ~REG_NOSUB;
594 break;
595 case LABEL_OPT:
596 label = optarg;
597 break;
598 case LINEBUF_OPT:
599 lbflag = true;
600 break;
601 case NULL_OPT:
602 nullflag = true;
603 break;
604 case R_INCLUDE_OPT:
605 finclude = true;
606 add_fpattern(optarg, INCL_PAT);
607 break;
608 case R_EXCLUDE_OPT:
609 fexclude = true;
610 add_fpattern(optarg, EXCL_PAT);
611 break;
612 case R_DINCLUDE_OPT:
613 dinclude = true;
614 add_dpattern(optarg, INCL_PAT);
615 break;
616 case R_DEXCLUDE_OPT:
617 dexclude = true;
618 add_dpattern(optarg, EXCL_PAT);
619 break;
620 case HELP_OPT:
621 default:
622 usage();
623 }
624 lastc = c;
625 newarg = optind != prevoptind;
626 prevoptind = optind;
627 }
628 aargc -= optind;
629 aargv += optind;
630
631 /* xflag takes precedence, don't confuse the matching bits. */
632 if (wflag && xflag)
633 wflag = false;
634
635 /* Fail if we don't have any pattern */
636 if (aargc == 0 && needpattern)
637 usage();
638
639 /* Process patterns from command line */
640 if (aargc != 0 && needpattern) {
641 char *token;
642 char *string = *aargv;
643
644 while ((token = strsep(&string, "\n")) != NULL)
645 add_pattern(token, strlen(token));
646 --aargc;
647 ++aargv;
648 }
649
650 switch (grepbehave) {
651 case GREP_BASIC:
652 break;
653 case GREP_FIXED:
654 /*
655 * regex(3) implementations that support fixed-string searches generally
656 * define either REG_NOSPEC or REG_LITERAL. Set the appropriate flag
657 * here. If neither are defined, GREP_FIXED later implies that the
658 * internal literal matcher should be used. Other cflags that have
659 * the same interpretation as REG_NOSPEC and REG_LITERAL should be
660 * similarly added here, and grep.h should be amended to take this into
661 * consideration when defining WITH_INTERNAL_NOSPEC.
662 */
663 #if defined(REG_NOSPEC)
664 cflags |= REG_NOSPEC;
665 #elif defined(REG_LITERAL)
666 cflags |= REG_LITERAL;
667 #endif
668 break;
669 case GREP_EXTENDED:
670 cflags |= REG_EXTENDED;
671 break;
672 default:
673 /* NOTREACHED */
674 usage();
675 }
676
677 r_pattern = grep_calloc(patterns, sizeof(*r_pattern));
678
679 #ifdef WITH_INTERNAL_NOSPEC
680 if (grepbehave != GREP_FIXED) {
681 #else
682 {
683 #endif
684 /* Check if cheating is allowed (always is for fgrep). */
685 for (i = 0; i < patterns; ++i) {
686 c = regcomp(&r_pattern[i], pattern[i].pat, cflags);
687 if (c != 0) {
688 regerror(c, &r_pattern[i], re_error,
689 RE_ERROR_BUF);
690 errx(2, "%s", re_error);
691 }
692 }
693 }
694
695 if (lbflag)
696 setlinebuf(stdout);
697
698 if ((aargc == 0 || aargc == 1) && !Hflag)
699 hflag = true;
700
701 initqueue();
702
703 if (aargc == 0 && dirbehave != DIR_RECURSE)
704 exit(!procfile("-"));
705
706 if (dirbehave == DIR_RECURSE)
707 matched = grep_tree(aargv);
708 else
709 for (matched = false; aargc--; ++aargv) {
710 if ((finclude || fexclude) && !file_matching(*aargv))
711 continue;
712 if (procfile(*aargv))
713 matched = true;
714 }
715
716 if (Lflag)
717 matched = !matched;
718
719 /*
720 * Calculate the correct return value according to the
721 * results and the command line option.
722 */
723 exit(matched ? (file_err ? (qflag ? 0 : 2) : 0) : (file_err ? 2 : 1));
724 }
725