Man Pages

grep(1) - phpMan grep(1) - phpMan

Command: man perldoc info search(apropos)  


GREP(1)                                                                GREP(1)



NAME
       grep, egrep, fgrep - print lines matching a pattern

SYNOPSIS
       grep [OPTIONS] PATTERN [FILE...]
       grep [OPTIONS] [-e PATTERN | -f FILE] [FILE...]

DESCRIPTION
       grep  searches  the named input FILEs (or standard input if no files are named, or if a single hyphen-minus (-)
       is given as file name) for lines containing a match to the given PATTERN.  By default, grep prints the matching
       lines.

       In  addition,  two variant programs egrep and fgrep are available.  egrep is the same as grep -E.  fgrep is the
       same as grep -F.  Direct invocation as either egrep or fgrep is deprecated, but is provided to allow historical
       applications that rely on them to run unmodified.

OPTIONS
   Generic Program Information
       --help Print a usage message briefly summarizing these command-line options and the bug-reporting address, then
              exit.

       -V, --version
              Print the version number of grep to the standard output stream.  This version number should be  included
              in all bug reports (see below).

   Matcher Selection
       -E, --extended-regexp
              Interpret PATTERN as an extended regular expression (ERE, see below).  (-E is specified by POSIX.)

       -F, --fixed-strings, --fixed-regexp
              Interpret PATTERN as a list of fixed strings, separated by newlines, any of which is to be matched.  (-F
              is specified by POSIX, --fixed-regexp is an obsoleted alias, please do not use it new scripts.)

       -G, --basic-regexp
              Interpret PATTERN as a basic regular expression (BRE, see below).  This is the default.

       -P, --perl-regexp
              Interpret PATTERN as a Perl regular expression.  This is highly experimental and grep  -P  may  warn  of
              unimplemented features.

   Matching Control
       -e PATTERN, --regexp=PATTERN
              Use  PATTERN  as  the  pattern.   This  can be used to specify multiple search patterns, or to protect a
              pattern beginning with a hyphen (-).  (-e is specified by POSIX.)

       -f FILE, --file=FILE
              Obtain patterns from FILE, one per line.  The empty file contains zero patterns, and  therefore  matches
              nothing.  (-f is specified by POSIX.)

       -i, --ignore-case
              Ignore case distinctions in both the PATTERN and the input files.  (-i is specified by POSIX.)

       -v, --invert-match
              Invert the sense of matching, to select non-matching lines.  (-v is specified by POSIX.)

       -w, --word-regexp
              Select  only  those  lines  containing  matches  that  form  whole words.  The test is that the matching
              substring must either be at the beginning of the line, or preceded by a non-word constituent  character.
              Similarly,  it  must  be  either at the end of the line or followed by a non-word constituent character.
              Word-constituent characters are letters, digits, and the underscore.

       -x, --line-regexp
              Select only those matches that exactly match the whole line.  (-x is specified by POSIX.)

       -y     Obsolete synonym for -i.

   General Output Control
       -c, --count
              Suppress normal output; instead print a count of matching lines for  each  input  file.   With  the  -v,
              --invert-match option (see below), count non-matching lines.  (-c is specified by POSIX.)

       --color[=WHEN], --colour[=WHEN]
              Surround  the matched (non-empty) strings, matching lines, context lines, file names, line numbers, byte
              offsets, and separators (for fields and groups of context lines) with escape sequences to  display  them
              in  color  on  the  terminal.   The  colors  are  defined  by the environment variable GREP_COLORS.  The
              deprecated environment variable GREP_COLOR is still supported, but its setting does not  have  priority.
              WHEN is never, always, or auto.

       -L, --files-without-match
              Suppress  normal  output;  instead print the name of each input file from which no output would normally
              have been printed.  The scanning will stop on the first match.

       -l, --files-with-matches
              Suppress normal output; instead print the name of each input file from which output would normally  have
              been printed.  The scanning will stop on the first match.  (-l is specified by POSIX.)

       -m NUM, --max-count=NUM
              Stop  reading  a file after NUM matching lines.  If the input is standard input from a regular file, and
              NUM matching lines are output, grep ensures that the standard input is positioned to just after the last
              matching  line  before  exiting,  regardless  of the presence of trailing context lines.  This enables a
              calling process to resume a search.  When grep stops after NUM matching lines, it outputs  any  trailing
              context  lines.   When  the -c or --count option is also used, grep does not output a count greater than
              NUM.  When the -v or --invert-match option is also used, grep stops after  outputting  NUM  non-matching
              lines.

       -o, --only-matching
              Print  only  the  matched (non-empty) parts of a matching line, with each such part on a separate output
              line.

       -q, --quiet, --silent
              Quiet; do not write anything to standard output.  Exit immediately with zero  status  if  any  match  is
              found,  even  if  an  error was detected.  Also see the -s or --no-messages option.  (-q is specified by
              POSIX.)

       -s, --no-messages
              Suppress error messages about nonexistent or unreadable files.  Portability note: unlike GNU  grep,  7th
              Edition  Unix  grep  did  not  conform to POSIX, because it lacked -q and its -s option behaved like GNU
              grep's -q option.  USG-style grep also lacked -q but its -s option  behaved  like  GNU  grep.   Portable
              shell  scripts  should  avoid  both -q and -s and should redirect standard and error output to /dev/null
              instead.  (-s is specified by POSIX.)

   Output Line Prefix Control
       -b, --byte-offset
              Print the 0-based byte offset within the input file before each line of output.  If -o (--only-matching)
              is specified, print the offset of the matching part itself.

       -H, --with-filename
              Print the file name for each match.  This is the default when there is more than one file to search.

       -h, --no-filename
              Suppress  the  prefixing  of  file names on output.  This is the default when there is only one file (or
              only standard input) to search.

       --label=LABEL
              Display input actually coming from standard input as input coming from file LABEL.  This  is  especially
              useful  when  implementing tools like zgrep, e.g., gzip -cd foo.gz | grep --label=foo -H something.  See
              also the -H option.

       -n, --line-number
              Prefix each line of output with the 1-based line number within its input  file.   (-n  is  specified  by
              POSIX.)

       -T, --initial-tab
              Make  sure  that the first character of actual line content lies on a tab stop, so that the alignment of
              tabs looks normal.  This is useful with options that prefix their output to the actual  content:  -H,-n,
              and  -b.   In  order to improve the probability that lines from a single file will all start at the same
              column, this also causes the line number and byte offset (if present) to be printed in  a  minimum  size
              field width.

       -u, --unix-byte-offsets
              Report  Unix-style  byte  offsets.  This switch causes grep to report byte offsets as if the file were a
              Unix-style text file, i.e., with CR characters stripped off.  This will  produce  results  identical  to
              running  grep  on  a  Unix  machine.  This option has no effect unless -b option is also used; it has no
              effect on platforms other than MS-DOS and MS-Windows.

       -Z, --null
              Output a zero byte (the ASCII NUL character) instead of the character that normally follows a file name.
              For  example,  grep  -lZ  outputs  a  zero byte after each file name instead of the usual newline.  This
              option makes the output unambiguous, even in the presence of file names  containing  unusual  characters
              like  newlines.  This option can be used with commands like find -print0, perl -0, sort -z, and xargs -0
              to process arbitrary file names, even those that contain newline characters.

   Context Line Control
       -A NUM, --after-context=NUM
              Print NUM lines of trailing context after matching lines.  Places a line containing  a  group  separator
              (described   under   --group-separator)   between   contiguous  groups  of  matches.   With  the  -o  or
              --only-matching option, this has no effect and a warning is given.

       -B NUM, --before-context=NUM
              Print NUM lines of leading context before matching lines.  Places a line containing  a  group  separator
              (described   under   --group-separator)   between   contiguous  groups  of  matches.   With  the  -o  or
              --only-matching option, this has no effect and a warning is given.

       -C NUM, -NUM, --context=NUM
              Print NUM lines of output context.   Places  a  line  containing  a  group  separator  (described  under
              --group-separator)  between  contiguous  groups of matches.  With the -o or --only-matching option, this
              has no effect and a warning is given.

       --group-separator=SEP
              Use SEP as a group separator. By default SEP is double hyphen (--).

       --no-group-separator
              Use empty string as a group separator.

   File and Directory Selection
       -a, --text
              Process a binary file as if it were text; this is equivalent to the --binary-files=text option.

       --binary-files=TYPE
              If the first few bytes of a file indicate that the file contains binary data, assume that the file is of
              type  TYPE.  By default, TYPE is binary, and grep normally outputs either a one-line message saying that
              a binary file matches, or no message if there is no match.  If TYPE is without-match, grep assumes  that
              a  binary  file  does not match; this is equivalent to the -I option.  If TYPE is text, grep processes a
              binary file as if it were text; this is equivalent to the -a option.  Warning: grep  --binary-files=text
              might  output  binary  garbage, which can have nasty side effects if the output is a terminal and if the
              terminal driver interprets some of it as commands.

       -D ACTION, --devices=ACTION
              If an input file is a device, FIFO or socket, use ACTION to process it.  By  default,  ACTION  is  read,
              which  means  that devices are read just as if they were ordinary files.  If ACTION is skip, devices are
              silently skipped.

       -d ACTION, --directories=ACTION
              If an input file is a directory, use ACTION to process it.  By  default,  ACTION  is  read,  i.e.,  read
              directories  just  as  if  they  were ordinary files.  If ACTION is skip, silently skip directories.  If
              ACTION is recurse, read all files under each directory, recursively, following symbolic  links  only  if
              they are on the command line.  This is equivalent to the -r option.

       --exclude=GLOB
              Skip  files  whose base name matches GLOB (using wildcard matching).  A file-name glob can use *, ?, and
              [...]  as wildcards, and \ to quote a wildcard or backslash character literally.

       --exclude-from=FILE
              Skip files whose base name matches any of the file-name globs read from FILE (using wildcard matching as
              described under --exclude).

       --exclude-dir=DIR
              Exclude directories matching the pattern DIR from recursive searches.

       -I     Process   a  binary  file  as  if  it  did  not  contain  matching  data;  this  is  equivalent  to  the
              --binary-files=without-match option.

       --include=GLOB
              Search only files whose base name matches GLOB (using wildcard matching as described under --exclude).

       -r, --recursive
              Read all files under each directory, recursively, following symbolic links  only  if  they  are  on  the
              command line.  This is equivalent to the -d recurse option.

       -R, --dereference-recursive
              Read all files under each directory, recursively.  Follow all symbolic links, unlike -r.

   Other Options
       --line-buffered
              Use line buffering on output.  This can cause a performance penalty.

       -U, --binary
              Treat  the  file(s)  as  binary.  By default, under MS-DOS and MS-Windows, grep guesses the file type by
              looking at the contents of the first 32KB read from the file.  If grep decides the file is a text  file,
              it  strips  the  CR characters from the original file contents (to make regular expressions with ^ and $
              work correctly).  Specifying -U overrules this guesswork, causing all files to be read and passed to the
              matching  mechanism  verbatim; if the file is a text file with CR/LF pairs at the end of each line, this
              will cause some regular expressions to fail.  This option has no effect on platforms other  than  MS-DOS
              and MS-Windows.

       -z, --null-data
              Treat the input as a set of lines, each terminated by a zero byte (the ASCII NUL character) instead of a
              newline.  Like the -Z or --null option, this option can be used with commands like sort  -z  to  process
              arbitrary file names.

REGULAR EXPRESSIONS
       A  regular  expression  is  a  pattern  that  describes  a set of strings.  Regular expressions are constructed
       analogously to arithmetic expressions, by using various operators to combine smaller expressions.

       grep understands three different versions of regular expression syntax:  "basic,"  "extended"  and  "perl."  In
       GNU grep,  there  is  no  difference  in available functionality between basic and extended syntaxes.  In other
       implementations, basic regular expressions are less powerful.  The following description  applies  to  extended
       regular  expressions;  differences  for  basic  regular  expressions  are  summarized afterwards.  Perl regular
       expressions give additional functionality, and are documented in pcresyntax(3) and pcrepattern(3), but may  not
       be available on every system.

       The  fundamental  building  blocks are the regular expressions that match a single character.  Most characters,
       including all letters and digits, are regular expressions  that  match  themselves.   Any  meta-character  with
       special meaning may be quoted by preceding it with a backslash.

       The period . matches any single character.

   Character Classes and Bracket Expressions
       A  bracket  expression  is  a  list of characters enclosed by [ and ].  It matches any single character in that
       list; if the first character of the list is the caret ^ then it matches any character not  in  the  list.   For
       example, the regular expression [0123456789] matches any single digit.

       Within  a  bracket expression, a range expression consists of two characters separated by a hyphen.  It matches
       any single character that sorts between the two characters, inclusive, using the  locale's  collating  sequence
       and  character  set.   For  example, in the default C locale, [a-d] is equivalent to [abcd].  Many locales sort
       characters in dictionary order, and in these locales [a-d] is typically not equivalent to [abcd]; it  might  be
       equivalent to [aBbCcDd], for example.  To obtain the traditional interpretation of bracket expressions, you can
       use the C locale by setting the LC_ALL environment variable to the value C.

       Finally, certain named classes of characters are predefined within  bracket  expressions,  as  follows.   Their
       names  are  self  explanatory,  and  they are [:alnum:], [:alpha:], [:cntrl:], [:digit:], [:graph:], [:lower:],
       [:print:], [:punct:], [:space:], [:upper:], and [:xdigit:].  For example, [[:alnum:]] means the character class
       of  numbers  and  letters  in the current locale. In the C locale and ASCII character set encoding, this is the
       same as [0-9A-Za-z].  (Note that the brackets in these class names are part of the symbolic names, and must  be
       included  in  addition  to  the  brackets  delimiting the bracket expression.)  Most meta-characters lose their
       special meaning inside bracket expressions.  To include a literal ] place it first in the list.  Similarly,  to
       include a literal ^ place it anywhere but first.  Finally, to include a literal - place it last.

   Anchoring
       The caret ^ and the dollar sign $ are meta-characters that respectively match the empty string at the beginning
       and end of a line.

   The Backslash Character and Special Expressions
       The symbols \< and \> respectively match the empty string at the beginning and end of a word.   The  symbol  \b
       matches  the  empty string at the edge of a word, and \B matches the empty string provided it's not at the edge
       of a word.  The symbol \w is a synonym for [_[:alnum:]] and \W is a synonym for [^_[:alnum:]].

   Repetition
       A regular expression may be followed by one of several repetition operators:
       ?      The preceding item is optional and matched at most once.
       *      The preceding item will be matched zero or more times.
       +      The preceding item will be matched one or more times.
       {n}    The preceding item is matched exactly n times.
       {n,}   The preceding item is matched n or more times.
       {,m}   The preceding item is matched at most m times.  This is a GNU extension.
       {n,m}  The preceding item is matched at least n times, but not more than m times.

   Concatenation
       Two regular expressions may be concatenated; the resulting regular expression  matches  any  string  formed  by
       concatenating two substrings that respectively match the concatenated expressions.

   Alternation
       Two  regular  expressions  may  be joined by the infix operator |; the resulting regular expression matches any
       string matching either alternate expression.

   Precedence
       Repetition takes precedence over concatenation, which in turn  takes  precedence  over  alternation.   A  whole
       expression may be enclosed in parentheses to override these precedence rules and form a subexpression.

   Back References and Subexpressions
       The  back-reference  \n,  where  n  is  a  single  digit,  matches  the substring previously matched by the nth
       parenthesized subexpression of the regular expression.

   Basic vs Extended Regular Expressions
       In basic regular expressions the meta-characters ?, +, {, |, (, and ) lose their special meaning;  instead  use
       the backslashed versions \?, \+, \{, \|, \(, and \).

       Traditional  egrep  did not support the { meta-character, and some egrep implementations support \{ instead, so
       portable scripts should avoid { in grep -E patterns and should use [{] to match a literal {.

       GNU grep -E attempts to support traditional usage by assuming that { is not special if it would be the start of
       an invalid interval specification.  For example, the command grep -E '{1' searches for the two-character string
       {1 instead of reporting a syntax error in the regular expression.  POSIX allows this behavior as an  extension,
       but portable scripts should avoid it.

ENVIRONMENT VARIABLES
       The behavior of grep is affected by the following environment variables.

       The  locale for category LC_foo is specified by examining the three environment variables LC_ALL, LC_foo, LANG,
       in that order.  The first of these variables that is set specifies the locale.  For example, if LC_ALL  is  not
       set,  but  LC_MESSAGES  is  set  to  pt_BR,  then  the  Brazilian Portuguese locale is used for the LC_MESSAGES
       category.  The C locale is used if none of these environment variables are set, if the locale  catalog  is  not
       installed, or if grep was not compiled with national language support (NLS).

       GREP_OPTIONS
              This  variable specifies default options to be placed in front of any explicit options.  For example, if
              GREP_OPTIONS is '--binary-files=without-match --directories=skip', grep behaves as if  the  two  options
              --binary-files=without-match  and  --directories=skip  had  been  specified before any explicit options.
              Option specifications are separated by whitespace.  A backslash escapes the next character, so it can be
              used to specify an option containing whitespace or a backslash.

       GREP_COLOR
              This variable specifies the color used to highlight matched (non-empty) text.  It is deprecated in favor
              of GREP_COLORS, but still supported.  The mt, ms, and mc capabilities of GREP_COLORS have priority  over
              it.  It can only specify the color used to highlight the matching non-empty text in any matching line (a
              selected line when the -v command-line option is omitted, or a context line when -v is specified).   The
              default is 01;31, which means a bold red foreground text on the terminal's default background.

       GREP_COLORS
              Specifies the colors and other attributes used to highlight various parts of the output.  Its value is a
              colon-separated list of capabilities that defaults to  ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36
              with the rv and ne boolean capabilities omitted (i.e., false).  Supported capabilities are as follows.

              sl=    SGR  substring  for whole selected lines (i.e., matching lines when the -v command-line option is
                     omitted, or non-matching lines when -v is specified).  If however the boolean rv  capability  and
                     the -v command-line option are both specified, it applies to context matching lines instead.  The
                     default is empty (i.e., the terminal's default color pair).

              cx=    SGR substring for whole context lines (i.e., non-matching lines when the -v  command-line  option
                     is  omitted,  or  matching lines when -v is specified).  If however the boolean rv capability and
                     the -v command-line option are both specified, it applies to selected non-matching lines instead.
                     The default is empty (i.e., the terminal's default color pair).

              rv     Boolean  value  that  reverses  (swaps)  the meanings of the sl= and cx= capabilities when the -v
                     command-line option is specified.  The default is false (i.e., the capability is omitted).

              mt=01;31
                     SGR substring for matching non-empty text in any matching line (i.e., a selected line when the -v
                     command-line  option  is  omitted,  or  a  context  line  when -v is specified).  Setting this is
                     equivalent to setting both ms= and mc= at once to the same value.  The default is a bold red text
                     foreground over the current line background.

              ms=01;31
                     SGR  substring  for  matching  non-empty text in a selected line.  (This is only used when the -v
                     command-line option is omitted.)  The effect of the sl= (or cx= if rv) capability remains  active
                     when  this kicks in.  The default is a bold red text foreground over the current line background.

              mc=01;31
                     SGR substring for matching non-empty text in a context line.  (This is  only  used  when  the  -v
                     command-line  option  is  specified.)   The  effect  of the cx= (or sl= if rv) capability remains
                     active when this kicks in.  The default is a bold red  text  foreground  over  the  current  line
                     background.

              fn=35  SGR  substring  for  file  names  prefixing  any  content  line.   The  default is a magenta text
                     foreground over the terminal's default background.

              ln=32  SGR substring for line numbers  prefixing  any  content  line.   The  default  is  a  green  text
                     foreground over the terminal's default background.

              bn=32  SGR  substring  for  byte  offsets  prefixing  any  content  line.   The  default is a green text
                     foreground over the terminal's default background.

              se=36  SGR substring for separators that are inserted between selected line fields (:), between  context
                     line  fields,  (-),  and between groups of adjacent lines when nonzero context is specified (--).
                     The default is a cyan text foreground over the terminal's default background.

              ne     Boolean value that prevents clearing to the end of line using Erase in Line (EL) to Right (\33[K)
                     each  time  a colorized item ends.  This is needed on terminals on which EL is not supported.  It
                     is otherwise useful on terminals for which the back_color_erase (bce) boolean terminfo capability
                     does  not apply, when the chosen highlight colors do not affect the background, or when EL is too
                     slow or causes too much flicker.  The default is false (i.e., the capability is omitted).

              Note that boolean capabilities have no =...  part.  They are omitted (i.e., false) by default and become
              true when specified.

              See  the  Select  Graphic Rendition (SGR) section in the documentation of the text terminal that is used
              for permitted values and their meaning as character attributes.  These substring values are integers  in
              decimal  representation  and  can  be  concatenated  with semicolons.  grep takes care of assembling the
              result into a complete SGR sequence (\33[...m).  Common values to concatenate include 1 for bold, 4  for
              underline,  5 for blink, 7 for inverse, 39 for default foreground color, 30 to 37 for foreground colors,
              90 to 97 for 16-color mode foreground colors, 38;5;0  to  38;5;255  for  88-color  and  256-color  modes
              foreground  colors,  49  for  default  background  color, 40 to 47 for background colors, 100 to 107 for
              16-color mode background colors, and 48;5;0 to 48;5;255 for  88-color  and  256-color  modes  background
              colors.

       LC_ALL, LC_COLLATE, LANG
              These  variables specify the locale for the LC_COLLATE category, which determines the collating sequence
              used to interpret range expressions like [a-z].

       LC_ALL, LC_CTYPE, LANG
              These variables specify the locale for the LC_CTYPE category, which determines the type  of  characters,
              e.g., which characters are whitespace.

       LC_ALL, LC_MESSAGES, LANG
              These variables specify the locale for the LC_MESSAGES category, which determines the language that grep
              uses for messages.  The default C locale uses American English messages.

       POSIXLY_CORRECT
              If set, grep behaves as POSIX requires; otherwise, grep behaves more like  other  GNU  programs.   POSIX
              requires that options that follow file names must be treated as file names; by default, such options are
              permuted to the front of the operand list and  are  treated  as  options.   Also,  POSIX  requires  that
              unrecognized  options  be  diagnosed  as  "illegal",  but  since they are not really against the law the
              default is to diagnose them as "invalid".  POSIXLY_CORRECT also  disables  _N_GNU_nonoption_argv_flags_,
              described below.

       _N_GNU_nonoption_argv_flags_
              (Here  N is grep's numeric process ID.)  If the ith character of this environment variable's value is 1,
              do not consider the ith operand of grep to be an option, even if it appears to be one.  A shell can  put
              this  variable in the environment for each command it runs, specifying which operands are the results of
              file name wildcard expansion and therefore should not be treated as options.  This behavior is available
              only with the GNU C library, and only when POSIXLY_CORRECT is not set.

EXIT STATUS
       Normally,  the  exit  status  is 0 if selected lines are found and 1 otherwise.  But the exit status is 2 if an
       error occurred, unless the -q or --quiet or --silent option is used  and  a  selected  line  is  found.   Note,
       however,  that  POSIX  only mandates, for programs such as grep, cmp, and diff, that the exit status in case of
       error be greater than 1; it is therefore advisable, for the sake of portability, to use logic  that  tests  for
       this general condition instead of strict equality with 2.

COPYRIGHT
       Copyright 1998-2000, 2002, 2005-2014 Free Software Foundation, Inc.

       This  is  free  software;  see  the  source  for  copying  conditions.   There  is  NO  warranty;  not even for
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

BUGS
   Reporting Bugs
       Email    bug    reports    to    <bug-grepATgnu.org>,    a    mailing     list     whose     web     page     is
       <http://lists.gnu.org/mailman/listinfo/bug-grep>.     grep's    Savannah    bug    tracker    is   located   at
       <http://savannah.gnu.org/bugs/?group=grep>.

   Known Bugs
       Large repetition counts in the {n,m} construct may cause grep to use lots  of  memory.   In  addition,  certain
       other  obscure regular expressions require exponential time and space, and may cause grep to run out of memory.

       Back-references are very slow, and may require exponential time.

SEE ALSO
   Regular Manual Pages
       awk(1), cmp(1), diff(1), find(1), gzip(1), perl(1), sed(1),  sort(1),  xargs(1),  zgrep(1),  read(2),  pcre(3),
       pcresyntax(3), pcrepattern(3), terminfo(5), glob(7), regex(7).

   POSIX Programmer's Manual Page
       grep(1p).

   TeXinfo Documentation
       The   full   documentation   for   grep   is   maintained   as   a  TeXinfo  manual,  which  you  can  read  at
       http://www.gnu.org/software/grep/manual/.  If the info and grep programs are properly installed at  your  site,
       the command

              info grep

       should give you access to the complete manual.

NOTES
       This man page is maintained only fitfully; the full documentation is often more up-to-date.

       GNU's not Unix, but Unix is a beast; its plural form is Unixen.



User Commands                    GNU grep 2.20                         GREP(1)