/* grep.c - main driver file for grep.

   Copyright (C) 1992, 1997-2002, 2004-2017 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* Written July 1992 by Mike Haertel.  */

#include <config.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <wchar.h>

#include <fcntl.h>

#include <inttypes.h>

#include <stdarg.h>

#include <stdio.h>

#include "system.h"

#include "argmatch.h"

#include "c-ctype.h"

#include "closeout.h"

#include "colorize.h"

#include "die.h"

#include "error.h"

#include "exclude.h"

#include "exitfail.h"

#include "fcntl-safer.h"

#include "fts_.h"

#include "getopt.h"

#include "getprogname.h"

#include "grep.h"

#include "intprops.h"

#include "propername.h"

#include "quote.h"

#include "safe-read.h"

#include "search.h"

#include "version-etc.h"

#include "xalloc.h"

#include "xbinary-io.h"

#include "xstrtol.h"

enum { SEP_CHAR_SELECTED = ':' };

enum { SEP_CHAR_REJECTED = '-' };

static char const SEP_STR_GROUP[] = "--";

#define AUTHORS \

  proper_name ("Mike Haertel"), \

  _("others, see <http://git.sv.gnu.org/cgit/grep.git/tree/AUTHORS>")

/* When stdout is connected to a regular file, save its stat

   information here, so that we can automatically skip it, thus

   avoiding a potential (racy) infinite loop.  */

static struct stat out_stat;

/* if non-zero, display usage information and exit */

static int show_help;

/* Print the version on standard output and exit.  */

static bool show_version;

/* Suppress diagnostics for nonexistent or unreadable files.  */

static bool suppress_errors;

/* If nonzero, use color markers.  */

static int color_option;

/* Show only the part of a line matching the expression. */

static bool only_matching;

/* If nonzero, make sure first content char in a line is on a tab stop. */

static bool align_tabs;

/* Print width of line numbers and byte offsets.  Nonzero if ALIGN_TABS.  */

static int offset_width;

/* See below */

struct FL_pair

  {

    char const *filename;

    size_t lineno;

  };

/* A list of lineno,filename pairs corresponding to -f FILENAME

   arguments. Since we store the concatenation of all patterns in

   a single array, KEYS, be they from the command line via "-e PAT"

   or read from one or more -f-specified FILENAMES.  Given this

   invocation, grep -f <(seq 5) -f <(seq 2) -f <(seq 3) FILE, there

   will be three entries in LF_PAIR: {1, x} {6, y} {8, z}, where

   x, y and z are just place-holders for shell-generated names.  */

static struct FL_pair *fl_pair;

static size_t n_fl_pair_slots;

/* Count not only -f-specified files, but also individual -e operands

   and any command-line argument that serves as a regular expression.  */

static size_t n_pattern_files;

/* The number of patterns seen so far.

   It is advanced by fl_add and, when needed, used in pattern_file_name

   to derive a file-relative line number.  */

static size_t n_patterns;

/* Return the number of newline bytes in BUF with size SIZE.  */

static size_t _GL_ATTRIBUTE_PURE

count_nl_bytes (char const *buf, size_t size)

{

  char const *p = buf;

  char const *end_p = buf + size;

  size_t n = 0;

  while ((p = memchr (p, '\n', end_p - p)))

    p++, n++;

  return n;

}

/* Append a FILENAME,line-number pair to FL_PAIR, and update

   pattern-related counts from the contents of BUF with SIZE bytes.  */

static void

fl_add (char const *buf, size_t size, char const *filename)

{

  if (n_fl_pair_slots <= n_pattern_files)

    fl_pair = x2nrealloc (fl_pair, &n_fl_pair_slots, sizeof *fl_pair);

  fl_pair[n_pattern_files].lineno = n_patterns + 1;

  fl_pair[n_pattern_files].filename = filename;

  n_pattern_files++;

  n_patterns += count_nl_bytes (buf, size);

}

/* Map the line number, LINENO, of one of the input patterns to the

   name of the file from which it came.  If it was read from stdin

   or if it was specified on the command line, return "-".  */

char const * _GL_ATTRIBUTE_PURE

pattern_file_name (size_t lineno, size_t *new_lineno)

{

  size_t i;

  for (i = 1; i < n_pattern_files; i++)

    {

      if (lineno < fl_pair[i].lineno)

        break;

    }

  *new_lineno = lineno - fl_pair[i - 1].lineno + 1;

  return fl_pair[i - 1].filename;

}

#if HAVE_ASAN

/* Record the starting address and length of the sole poisoned region,

   so that we can unpoison it later, just before each following read.  */

static void const *poison_buf;

static size_t poison_len;

static void

clear_asan_poison (void)

{

  if (poison_buf)

    __asan_unpoison_memory_region (poison_buf, poison_len);

}

static void

asan_poison (void const *addr, size_t size)

{

  poison_buf = addr;

  poison_len = size;

  __asan_poison_memory_region (poison_buf, poison_len);

}

#else

static void clear_asan_poison (void) { }

static void asan_poison (void const volatile *addr, size_t size) { }

#endif

/* The group separator used when context is requested. */

static const char *group_separator = SEP_STR_GROUP;

/* The context and logic for choosing default --color screen attributes

   (foreground and background colors, etc.) are the following.

      -- There are eight basic colors available, each with its own

         nominal luminosity to the human eye and foreground/background

         codes (black [0 %, 30/40], blue [11 %, 34/44], red [30 %, 31/41],

         magenta [41 %, 35/45], green [59 %, 32/42], cyan [70 %, 36/46],

         yellow [89 %, 33/43], and white [100 %, 37/47]).

      -- Sometimes, white as a background is actually implemented using

         a shade of light gray, so that a foreground white can be visible

         on top of it (but most often not).

      -- Sometimes, black as a foreground is actually implemented using

         a shade of dark gray, so that it can be visible on top of a

         background black (but most often not).

      -- Sometimes, more colors are available, as extensions.

      -- Other attributes can be selected/deselected (bold [1/22],

         underline [4/24], standout/inverse [7/27], blink [5/25], and

         invisible/hidden [8/28]).  They are sometimes implemented by

         using colors instead of what their names imply; e.g., bold is

         often achieved by using brighter colors.  In practice, only bold

         is really available to us, underline sometimes being mapped by

         the terminal to some strange color choice, and standout best

         being left for use by downstream programs such as less(1).

      -- We cannot assume that any of the extensions or special features

         are available for the purpose of choosing defaults for everyone.

      -- The most prevalent default terminal backgrounds are pure black

         and pure white, and are not necessarily the same shades of

         those as if they were selected explicitly with SGR sequences.

         Some terminals use dark or light pictures as default background,

         but those are covered over by an explicit selection of background

         color with an SGR sequence; their users will appreciate their

         background pictures not be covered like this, if possible.

      -- Some uses of colors attributes is to make some output items

         more understated (e.g., context lines); this cannot be achieved

         by changing the background color.

      -- For these reasons, the grep color defaults should strive not

         to change the background color from its default, unless it's

         for a short item that should be highlighted, not understated.

      -- The grep foreground color defaults (without an explicitly set

         background) should provide enough contrast to be readable on any

         terminal with either a black (dark) or white (light) background.

         This only leaves red, magenta, green, and cyan (and their bold

         counterparts) and possibly bold blue.  */

/* The color strings used for matched text.

   The user can overwrite them using the deprecated

   environment variable GREP_COLOR or the new GREP_COLORS.  */

static const char *selected_match_color = "01;31";	/* bold red */

static const char *context_match_color  = "01;31";	/* bold red */

/* Other colors.  Defaults look damn good.  */

static const char *filename_color = "35";	/* magenta */

static const char *line_num_color = "32";	/* green */

static const char *byte_num_color = "32";	/* green */

static const char *sep_color      = "36";	/* cyan */

static const char *selected_line_color = "";	/* default color pair */

static const char *context_line_color  = "";	/* default color pair */

/* Select Graphic Rendition (SGR, "\33[...m") strings.  */

/* Also Erase in Line (EL) to Right ("\33[K") by default.  */

/*    Why have EL to Right after SGR?

         -- The behavior of line-wrapping when at the bottom of the

            terminal screen and at the end of the current line is often

            such that a new line is introduced, entirely cleared with

            the current background color which may be different from the

            default one (see the boolean back_color_erase terminfo(5)

            capability), thus scrolling the display by one line.

            The end of this new line will stay in this background color

            even after reverting to the default background color with

            "\33[m', unless it is explicitly cleared again with "\33[K"

            (which is the behavior the user would instinctively expect

            from the whole thing).  There may be some unavoidable

            background-color flicker at the end of this new line because

            of this (when timing with the monitor's redraw is just right).

         -- The behavior of HT (tab, "\t") is usually the same as that of

            Cursor Forward Tabulation (CHT) with a default parameter

            of 1 ("\33[I"), i.e., it performs pure movement to the next

            tab stop, without any clearing of either content or screen

            attributes (including background color); try

               printf 'asdfqwerzxcv\rASDF\tZXCV\n'

            in a bash(1) shell to demonstrate this.  This is not what the

            user would instinctively expect of HT (but is ok for CHT).

            The instinctive behavior would include clearing the terminal

            cells that are skipped over by HT with blank cells in the

            current screen attributes, including background color;

            the boolean dest_tabs_magic_smso terminfo(5) capability

            indicates this saner behavior for HT, but only some rare

            terminals have it (although it also indicates a special

            glitch with standout mode in the Teleray terminal for which

            it was initially introduced).  The remedy is to add "\33K"

            after each SGR sequence, be it START (to fix the behavior

            of any HT after that before another SGR) or END (to fix the

            behavior of an HT in default background color that would

            follow a line-wrapping at the bottom of the screen in another

            background color, and to complement doing it after START).

            Piping grep's output through a pager such as less(1) avoids

            any HT problems since the pager performs tab expansion.

      Generic disadvantages of this remedy are:

         -- Some very rare terminals might support SGR but not EL (nobody

            will use "grep --color" on a terminal that does not support

            SGR in the first place).

         -- Having these extra control sequences might somewhat complicate

            the task of any program trying to parse "grep --color"

            output in order to extract structuring information from it.

      A specific disadvantage to doing it after SGR START is:

         -- Even more possible background color flicker (when timing

            with the monitor's redraw is just right), even when not at the

            bottom of the screen.

      There are no additional disadvantages specific to doing it after

      SGR END.

      It would be impractical for GNU grep to become a full-fledged

      terminal program linked against ncurses or the like, so it will

      not detect terminfo(5) capabilities.  */

static const char *sgr_start = "\33[%sm\33[K";

static const char *sgr_end   = "\33[m\33[K";

/* SGR utility functions.  */

static void

pr_sgr_start (char const *s)

{

  if (*s)

    print_start_colorize (sgr_start, s);

}

static void

pr_sgr_end (char const *s)

{

  if (*s)

    print_end_colorize (sgr_end);

}

static void

pr_sgr_start_if (char const *s)

{

  if (color_option)

    pr_sgr_start (s);

}

static void

pr_sgr_end_if (char const *s)

{

  if (color_option)

    pr_sgr_end (s);

}

struct color_cap

  {

    const char *name;

    const char **var;

    void (*fct) (void);

  };

static void

color_cap_mt_fct (void)

{

  /* Our caller just set selected_match_color.  */

  context_match_color = selected_match_color;

}

static void

color_cap_rv_fct (void)

{

  /* By this point, it was 1 (or already -1).  */

  color_option = -1;  /* That's still != 0.  */

}

static void

color_cap_ne_fct (void)

{

  sgr_start = "\33[%sm";

  sgr_end   = "\33[m";

}

/* For GREP_COLORS.  */

static const struct color_cap color_dict[] =

  {

    { "mt", &selected_match_color, color_cap_mt_fct }, /* both ms/mc */

    { "ms", &selected_match_color, NULL }, /* selected matched text */

    { "mc", &context_match_color,  NULL }, /* context matched text */

    { "fn", &filename_color,       NULL }, /* filename */

    { "ln", &line_num_color,       NULL }, /* line number */

    { "bn", &byte_num_color,       NULL }, /* byte (sic) offset */

    { "se", &sep_color,            NULL }, /* separator */

    { "sl", &selected_line_color,  NULL }, /* selected lines */

    { "cx", &context_line_color,   NULL }, /* context lines */

    { "rv", NULL,                  color_cap_rv_fct }, /* -v reverses sl/cx */

    { "ne", NULL,                  color_cap_ne_fct }, /* no EL on SGR_* */

    { NULL, NULL,                  NULL }

  };

/* Saved errno value from failed output functions on stdout.  */

static int stdout_errno;

static void

putchar_errno (int c)

{

  if (putchar (c) < 0)

    stdout_errno = errno;

}

static void

fputs_errno (char const *s)

{

  if (fputs (s, stdout) < 0)

    stdout_errno = errno;

}

static void _GL_ATTRIBUTE_FORMAT_PRINTF (1, 2)

printf_errno (char const *format, ...)

{

  va_list ap;

  va_start (ap, format);

  if (vfprintf (stdout, format, ap) < 0)

    stdout_errno = errno;

  va_end (ap);

}

static void

fwrite_errno (void const *ptr, size_t size, size_t nmemb)

{

  if (fwrite (ptr, size, nmemb, stdout) != nmemb)

    stdout_errno = errno;

}

static void

fflush_errno (void)

{

  if (fflush (stdout) != 0)

    stdout_errno = errno;

}

static struct exclude *excluded_patterns[2];

static struct exclude *excluded_directory_patterns[2];

/* Short options.  */

static char const short_options[] =

"0123456789A:B:C:D:EFGHIPTUVX:abcd:e:f:hiLlm:noqRrsuvwxyZz";

/* Non-boolean long options that have no corresponding short equivalents.  */

enum

{

  BINARY_FILES_OPTION = CHAR_MAX + 1,

  COLOR_OPTION,

  EXCLUDE_DIRECTORY_OPTION,

  EXCLUDE_OPTION,

  EXCLUDE_FROM_OPTION,

  GROUP_SEPARATOR_OPTION,

  INCLUDE_OPTION,

  LINE_BUFFERED_OPTION,

  LABEL_OPTION

};

/* Long options equivalences. */

static struct option const long_options[] =

{

  {"basic-regexp",    no_argument, NULL, 'G'},

  {"extended-regexp", no_argument, NULL, 'E'},

  {"fixed-regexp",    no_argument, NULL, 'F'},

  {"fixed-strings",   no_argument, NULL, 'F'},

  {"perl-regexp",     no_argument, NULL, 'P'},

  {"after-context", required_argument, NULL, 'A'},

  {"before-context", required_argument, NULL, 'B'},

  {"binary-files", required_argument, NULL, BINARY_FILES_OPTION},

  {"byte-offset", no_argument, NULL, 'b'},

  {"context", required_argument, NULL, 'C'},

  {"color", optional_argument, NULL, COLOR_OPTION},

  {"colour", optional_argument, NULL, COLOR_OPTION},

  {"count", no_argument, NULL, 'c'},

  {"devices", required_argument, NULL, 'D'},

  {"directories", required_argument, NULL, 'd'},

  {"exclude", required_argument, NULL, EXCLUDE_OPTION},

  {"exclude-from", required_argument, NULL, EXCLUDE_FROM_OPTION},

  {"exclude-dir", required_argument, NULL, EXCLUDE_DIRECTORY_OPTION},

  {"file", required_argument, NULL, 'f'},

  {"files-with-matches", no_argument, NULL, 'l'},

  {"files-without-match", no_argument, NULL, 'L'},

  {"group-separator", required_argument, NULL, GROUP_SEPARATOR_OPTION},

  {"help", no_argument, &show_help, 1},

  {"include", required_argument, NULL, INCLUDE_OPTION},

  {"ignore-case", no_argument, NULL, 'i'},

  {"initial-tab", no_argument, NULL, 'T'},

  {"label", required_argument, NULL, LABEL_OPTION},

  {"line-buffered", no_argument, NULL, LINE_BUFFERED_OPTION},

  {"line-number", no_argument, NULL, 'n'},

  {"line-regexp", no_argument, NULL, 'x'},

  {"max-count", required_argument, NULL, 'm'},

  {"no-filename", no_argument, NULL, 'h'},

  {"no-group-separator", no_argument, NULL, GROUP_SEPARATOR_OPTION},

  {"no-messages", no_argument, NULL, 's'},

  {"null", no_argument, NULL, 'Z'},

  {"null-data", no_argument, NULL, 'z'},

  {"only-matching", no_argument, NULL, 'o'},

  {"quiet", no_argument, NULL, 'q'},

  {"recursive", no_argument, NULL, 'r'},

  {"dereference-recursive", no_argument, NULL, 'R'},

  {"regexp", required_argument, NULL, 'e'},

  {"invert-match", no_argument, NULL, 'v'},

  {"silent", no_argument, NULL, 'q'},

  {"text", no_argument, NULL, 'a'},

  {"binary", no_argument, NULL, 'U'},

  {"unix-byte-offsets", no_argument, NULL, 'u'},

  {"version", no_argument, NULL, 'V'},

  {"with-filename", no_argument, NULL, 'H'},

  {"word-regexp", no_argument, NULL, 'w'},

  {0, 0, 0, 0}

};

/* Define flags declared in grep.h. */

bool match_icase;

bool match_words;

bool match_lines;

char eolbyte;

/* For error messages. */

/* The input file name, or (if standard input) null or a --label argument.  */

static char const *filename;

/* Omit leading "./" from file names in diagnostics.  */

static bool omit_dot_slash;

static bool errseen;

/* True if output from the current input file has been suppressed

   because an output line had an encoding error.  */

static bool encoding_error_output;

enum directories_type

  {

    READ_DIRECTORIES = 2,

    RECURSE_DIRECTORIES,

    SKIP_DIRECTORIES

  };

/* How to handle directories.  */

static char const *const directories_args[] =

{

  "read", "recurse", "skip", NULL

};

static enum directories_type const directories_types[] =

{

  READ_DIRECTORIES, RECURSE_DIRECTORIES, SKIP_DIRECTORIES

};

ARGMATCH_VERIFY (directories_args, directories_types);

static enum directories_type directories = READ_DIRECTORIES;

enum { basic_fts_options = FTS_CWDFD | FTS_NOSTAT | FTS_TIGHT_CYCLE_CHECK };

static int fts_options = basic_fts_options | FTS_COMFOLLOW | FTS_PHYSICAL;

/* How to handle devices. */

static enum

  {

    READ_COMMAND_LINE_DEVICES,

    READ_DEVICES,

    SKIP_DEVICES

  } devices = READ_COMMAND_LINE_DEVICES;

static bool grepfile (int, char const *, bool, bool);

static bool grepdesc (int, bool);

static bool

is_device_mode (mode_t m)

{

  return S_ISCHR (m) || S_ISBLK (m) || S_ISSOCK (m) || S_ISFIFO (m);

}

static bool

skip_devices (bool command_line)

{

  return (devices == SKIP_DEVICES

          || ((devices == READ_COMMAND_LINE_DEVICES) & !command_line));

}

/* Return if ST->st_size is defined.  Assume the file is not a

   symbolic link.  */

static bool

usable_st_size (struct stat const *st)

{

  return S_ISREG (st->st_mode) || S_TYPEISSHM (st) || S_TYPEISTMO (st);

}

/* Lame substitutes for SEEK_DATA and SEEK_HOLE on platforms lacking them.

   Do not rely on these finding data or holes if they equal SEEK_SET.  */

#ifndef SEEK_DATA

enum { SEEK_DATA = SEEK_SET };

#endif

#ifndef SEEK_HOLE

enum { SEEK_HOLE = SEEK_SET };

#endif

/* True if lseek with SEEK_CUR or SEEK_DATA failed on the current input.  */

static bool seek_failed;

static bool seek_data_failed;

/* Functions we'll use to search. */

typedef void *(*compile_fp_t) (char *, size_t, reg_syntax_t);

typedef size_t (*execute_fp_t) (void *, char const *, size_t, size_t *,

                                char const *);

static execute_fp_t execute;

static void *compiled_pattern;

static char const *

input_filename (void)

{

  if (!filename)

    filename = _("(standard input)");

  return filename;

}

/* Unless requested, diagnose an error about the input file.  */

static void

suppressible_error (int errnum)

{

  if (! suppress_errors)

    error (0, errnum, "%s", input_filename ());

  errseen = true;

}

/* If there has already been a write error, don't bother closing

   standard output, as that might elicit a duplicate diagnostic.  */

static void

clean_up_stdout (void)

{

  if (! stdout_errno)

    close_stdout ();

}

/* A cast to TYPE of VAL.  Use this when TYPE is a pointer type, VAL

   is properly aligned for TYPE, and 'gcc -Wcast-align' cannot infer

   the alignment and would otherwise complain about the cast.  */

#if 4 < __GNUC__ + (6 <= __GNUC_MINOR__)

# define CAST_ALIGNED(type, val)                           \

    ({ __typeof__ (val) val_ = val;                        \

       _Pragma ("GCC diagnostic push")                     \

       _Pragma ("GCC diagnostic ignored \"-Wcast-align\"") \

       (type) val_;                                        \

       _Pragma ("GCC diagnostic pop")                      \

    })

#else

# define CAST_ALIGNED(type, val) ((type) (val))

#endif

/* An unsigned type suitable for fast matching.  */

typedef uintmax_t uword;

struct localeinfo localeinfo;

/* A mask to test for unibyte characters, with the pattern repeated to

   fill a uword.  For a multibyte character encoding where

   all bytes are unibyte characters, this is 0.  For UTF-8, this is

   0x808080....  For encodings where unibyte characters have no discerned

   pattern, this is all 1s.  The unsigned char C is a unibyte

   character if C & UNIBYTE_MASK is zero.  If the uword W is the

   concatenation of bytes, the bytes are all unibyte characters

   if W & UNIBYTE_MASK is zero.  */

static uword unibyte_mask;

static void

initialize_unibyte_mask (void)

{

  /* For each encoding error I that MASK does not already match,

     accumulate I's most significant 1 bit by ORing it into MASK.

     Although any 1 bit of I could be used, in practice high-order

     bits work better.  */

  unsigned char mask = 0;

  int ms1b = 1;

  for (int i = 1; i <= UCHAR_MAX; i++)

    if ((localeinfo.sbclen[i] != 1) & ! (mask & i))

      {

        while (ms1b * 2 <= i)

          ms1b *= 2;

        mask |= ms1b;

      }

  /* Now MASK will detect any encoding-error byte, although it may

     cry wolf and it may not be optimal.  Build a uword-length mask by

     repeating MASK.  */

  uword uword_max = -1;

  unibyte_mask = uword_max / UCHAR_MAX * mask;

}

/* Skip the easy bytes in a buffer that is guaranteed to have a sentinel

   that is not easy, and return a pointer to the first non-easy byte.

   The easy bytes all have UNIBYTE_MASK off.  */

static char const * _GL_ATTRIBUTE_PURE

skip_easy_bytes (char const *buf)

{

  /* Search a byte at a time until the pointer is aligned, then a

     uword at a time until a match is found, then a byte at a time to

     identify the exact byte.  The uword search may go slightly past

     the buffer end, but that's benign.  */

  char const *p;

  uword const *s;

  for (p = buf; (uintptr_t) p % sizeof (uword) != 0; p++)

    if (to_uchar (*p) & unibyte_mask)

      return p;

  for (s = CAST_ALIGNED (uword const *, p); ! (*s & unibyte_mask); s++)

    continue;

  for (p = (char const *) s; ! (to_uchar (*p) & unibyte_mask); p++)

    continue;

  return p;

}

/* Return true if BUF, of size SIZE, has an encoding error.

   BUF must be followed by at least sizeof (uword) bytes,

   the first of which may be modified.  */

static bool

buf_has_encoding_errors (char *buf, size_t size)

{

  if (! unibyte_mask)

    return false;

  mbstate_t mbs = { 0 };

  size_t clen;

  buf[size] = -1;

  for (char const *p = buf; (p = skip_easy_bytes (p)) < buf + size; p += clen)

    {

      clen = mbrlen (p, buf + size - p, &mbs);

      if ((size_t) -2 <= clen)

        return true;

    }

  return false;

}

/* Return true if BUF, of size SIZE, has a null byte.

   BUF must be followed by at least one byte,

   which may be arbitrarily written to or read from.  */

static bool

buf_has_nulls (char *buf, size_t size)

{

  buf[size] = 0;

  return strlen (buf) != size;

}

/* Return true if a file is known to contain null bytes.

   SIZE bytes have already been read from the file

   with descriptor FD and status ST.  */

static bool

file_must_have_nulls (size_t size, int fd, struct stat const *st)

{

  /* If the file has holes, it must contain a null byte somewhere.  */

  if (SEEK_HOLE != SEEK_SET && !seek_failed

      && usable_st_size (st) && size < st->st_size)

    {

      off_t cur = size;

      if (O_BINARY || fd == STDIN_FILENO)

        {

          cur = lseek (fd, 0, SEEK_CUR);

          if (cur < 0)

            return false;

        }

      /* Look for a hole after the current location.  */

      off_t hole_start = lseek (fd, cur, SEEK_HOLE);

      if (0 <= hole_start)

        {

          if (lseek (fd, cur, SEEK_SET) < 0)

            suppressible_error (errno);

          if (hole_start < st->st_size)

            return true;

        }

    }

  return false;

}

/* Convert STR to a nonnegative integer, storing the result in *OUT.

   STR must be a valid context length argument; report an error if it

   isn't.  Silently ceiling *OUT at the maximum value, as that is

   practically equivalent to infinity for grep's purposes.  */

static void

context_length_arg (char const *str, intmax_t *out)

{

  switch (xstrtoimax (str, 0, 10, out, ""))

    {

    case LONGINT_OK:

    case LONGINT_OVERFLOW:

      if (0 <= *out)

        break;

      FALLTHROUGH;

    default:

      die (EXIT_TROUBLE, 0, "%s: %s", str,

           _("invalid context length argument"));

    }

}

/* Return the add_exclude options suitable for excluding a file name.

   If COMMAND_LINE, it is a command-line file name.  */

static int

exclude_options (bool command_line)

{

  return EXCLUDE_WILDCARDS | (command_line ? 0 : EXCLUDE_ANCHORED);

}

/* Return true if the file with NAME should be skipped.

   If COMMAND_LINE, it is a command-line argument.

   If IS_DIR, it is a directory.  */

static bool

skipped_file (char const *name, bool command_line, bool is_dir)

{

  struct exclude **pats;

  if (! is_dir)

    pats = excluded_patterns;

  else if (directories == SKIP_DIRECTORIES)

    return true;

  else if (command_line && omit_dot_slash)

    return false;

  else

    pats = excluded_directory_patterns;

  return pats[command_line] && excluded_file_name (pats[command_line], name);

}

/* Hairy buffering mechanism for grep.  The intent is to keep

   all reads aligned on a page boundary and multiples of the

   page size, unless a read yields a partial page.  */

static char *buffer;		/* Base of buffer. */

static size_t bufalloc;		/* Allocated buffer size, counting slop. */

enum { INITIAL_BUFSIZE = 32768 }; /* Initial buffer size, not counting slop. */

static int bufdesc;		/* File descriptor. */

static char *bufbeg;		/* Beginning of user-visible stuff. */

static char *buflim;		/* Limit of user-visible stuff. */

static size_t pagesize;		/* alignment of memory pages */

static off_t bufoffset;		/* Read offset.  */

static off_t after_last_match;	/* Pointer after last matching line that

                                   would have been output if we were

                                   outputting characters. */

static bool skip_nuls;		/* Skip '\0' in data.  */

static bool skip_empty_lines;	/* Skip empty lines in data.  */

static uintmax_t totalnl;	/* Total newline count before lastnl. */

/* Return VAL aligned to the next multiple of ALIGNMENT.  VAL can be

   an integer or a pointer.  Both args must be free of side effects.  */

#define ALIGN_TO(val, alignment) \

  ((size_t) (val) % (alignment) == 0 \

   ? (val) \

   : (val) + ((alignment) - (size_t) (val) % (alignment)))

/* Add two numbers that count input bytes or lines, and report an

   error if the addition overflows.  */

static uintmax_t

add_count (uintmax_t a, uintmax_t b)

{

  uintmax_t sum = a + b;

  if (sum < a)

    die (EXIT_TROUBLE, 0, _("input is too large to count"));

  return sum;

}

/* Return true if BUF (of size SIZE) is all zeros.  */

static bool

all_zeros (char const *buf, size_t size)

{

  for (char const *p = buf; p < buf + size; p++)

    if (*p)

      return false;

  return true;

}

/* Reset the buffer for a new file, returning false if we should skip it.

   Initialize on the first time through. */

static bool

reset (int fd, struct stat const *st)

{

  bufbeg = buflim = ALIGN_TO (buffer + 1, pagesize);

  bufbeg[-1] = eolbyte;

  bufdesc = fd;

  bufoffset = fd == STDIN_FILENO ? lseek (fd, 0, SEEK_CUR) : 0;

  seek_failed = bufoffset < 0;

  /* Assume SEEK_DATA fails if SEEK_CUR does.  */

  seek_data_failed = seek_failed;

  if (seek_failed)

    {

      if (errno != ESPIPE)

        {

          suppressible_error (errno);

          return false;

        }

      bufoffset = 0;

    }

  return true;

}

/* Read new stuff into the buffer, saving the specified

   amount of old stuff.  When we're done, 'bufbeg' points

   to the beginning of the buffer contents, and 'buflim'

   points just after the end.  Return false if there's an error.  */

static bool

fillbuf (size_t save, struct stat const *st)

{

  size_t fillsize;

  bool cc = true;

  char *readbuf;

  size_t readsize;

  /* Offset from start of buffer to start of old stuff