usr.bin/grep/grep.c

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