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