This is grep.info-t, produced by makeinfo version 6.3 from grep.texi.

This manual is for ‘grep’, a pattern matching engine.

   Copyright © 1999-2002, 2005, 2008-2017 Free Software Foundation, Inc.

     Permission is granted to copy, distribute and/or modify this

     document under the terms of the GNU Free Documentation License,

     Version 1.3 or any later version published by the Free Software

     Foundation; with no Invariant Sections, with no Front-Cover Texts,

     and with no Back-Cover Texts. A copy of the license is included in

     the section entitled “GNU Free Documentation License”.

INFO-DIR-SECTION Text creation and manipulation

START-INFO-DIR-ENTRY

* grep: (grep).                 Print lines matching a pattern.

END-INFO-DIR-ENTRY

?

File: grep.info-t,  Node: Top,  Next: Introduction,  Up: (dir)

grep

****

‘grep’ prints lines that contain a match for a pattern.

   This manual is for version 3.1 of GNU Grep.

   This manual is for ‘grep’, a pattern matching engine.

   Copyright © 1999-2002, 2005, 2008-2017 Free Software Foundation, Inc.

     Permission is granted to copy, distribute and/or modify this

     document under the terms of the GNU Free Documentation License,

     Version 1.3 or any later version published by the Free Software

     Foundation; with no Invariant Sections, with no Front-Cover Texts,

     and with no Back-Cover Texts.  A copy of the license is included in

     the section entitled “GNU Free Documentation License”.

* Menu:

* Introduction::                Introduction.

* Invoking::                    Command-line options, environment, exit status.

* Regular Expressions::         Regular Expressions.

* Usage::                       Examples.

* Performance::                 Performance tuning.

* Reporting Bugs::              Reporting Bugs.

* Copying::                     License terms for this manual.

* Index::                       Combined index.

?

File: grep.info-t,  Node: Introduction,  Next: Invoking,  Prev: Top,  Up: Top

1 Introduction

**************

‘grep’ searches input files for lines containing a match to a given

pattern list.  When it finds a match in a line, it copies the line to

standard output (by default), or produces whatever other sort of output

you have requested with options.

   Though ‘grep’ expects to do the matching on text, it has no limits on

input line length other than available memory, and it can match

arbitrary characters within a line.  If the final byte of an input file

is not a newline, ‘grep’ silently supplies one.  Since newline is also a

separator for the list of patterns, there is no way to match newline

characters in a text.

?

File: grep.info-t,  Node: Invoking,  Next: Regular Expressions,  Prev: Introduction,  Up: Top

2 Invoking ‘grep’

*****************

The general synopsis of the ‘grep’ command line is

     grep OPTIONS PATTERN INPUT_FILE_NAMES

There can be zero or more OPTIONS.  PATTERN will only be seen as such

(and not as an INPUT_FILE_NAME) if it wasn’t already specified within

OPTIONS (by using the ‘-e PATTERN’ or ‘-f FILE’ options).  There can be

zero or more INPUT_FILE_NAMES.

* Menu:

* Command-line Options::        Short and long names, grouped by category.

* Environment Variables::       POSIX, GNU generic, and GNU grep specific.

* Exit Status::                 Exit status returned by ‘grep’.

* grep Programs::               ‘grep’ programs.

?

File: grep.info-t,  Node: Command-line Options,  Next: Environment Variables,  Up: Invoking

2.1 Command-line Options

========================

‘grep’ comes with a rich set of options: some from POSIX and some being

GNU extensions.  Long option names are always a GNU extension, even for

options that are from POSIX specifications.  Options that are specified

by POSIX, under their short names, are explicitly marked as such to

facilitate POSIX-portable programming.  A few option names are provided

for compatibility with older or more exotic implementations.

* Menu:

* Generic Program Information::

* Matching Control::

* General Output Control::

* Output Line Prefix Control::

* Context Line Control::

* File and Directory Selection::

* Other Options::

   Several additional options control which variant of the ‘grep’

matching engine is used.  *Note grep Programs::.

?

File: grep.info-t,  Node: Generic Program Information,  Next: Matching Control,  Up: Command-line Options

2.1.1 Generic Program Information

---------------------------------

‘--help’

     Print a usage message briefly summarizing the 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.

?

File: grep.info-t,  Node: Matching Control,  Next: General Output Control,  Prev: Generic Program Information,  Up: Command-line Options

2.1.2 Matching Control

----------------------

‘-e PATTERN’

‘--regexp=PATTERN’

     Use PATTERN as the pattern.  If this option is used multiple times

     or is combined with the ‘-f’ (‘--file’) option, search for all

     patterns given.  (‘-e’ is specified by POSIX.)

‘-f FILE’

‘--file=FILE’

     Obtain patterns from FILE, one per line.  If this option is used

     multiple times or is combined with the ‘-e’ (‘--regexp’) option,

     search for all patterns given.  The empty file contains zero

     patterns, and therefore matches nothing.  (‘-f’ is specified by

     POSIX.)

‘-i’

‘-y’

‘--ignore-case’

     Ignore case distinctions, so that characters that differ only in

     case match each other.  Although this is straightforward when

     letters differ in case only via lowercase-uppercase pairs, the

     behavior is unspecified in other situations.  For example,

     uppercase “S” has an unusual lowercase counterpart “ſ” (Unicode

     character U+017F, LATIN SMALL LETTER LONG S) in many locales, and

     it is unspecified whether this unusual character matches “S” or “s”

     even though uppercasing it yields “S”.  Another example: the

     lowercase German letter “ß” (U+00DF, LATIN SMALL LETTER SHARP S) is

     normally capitalized as the two-character string “SS” but it does

     not match “SS”, and it might not match the uppercase letter “ẞ”

     (U+1E9E, LATIN CAPITAL LETTER SHARP S) even though lowercasing the

     latter yields the former.

     ‘-y’ is an obsolete synonym that is provided for compatibility.

     (‘-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.  This option

     has no effect if ‘-x’ is also specified.

‘-x’

‘--line-regexp’

     Select only those matches that exactly match the whole line.  For a

     regular expression pattern, this is like parenthesizing the pattern

     and then surrounding it with ‘^’ and ‘$’.  (‘-x’ is specified by

     POSIX.)

?

File: grep.info-t,  Node: General Output Control,  Next: Output Line Prefix Control,  Prev: Matching Control,  Up: Command-line Options

2.1.3 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, 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’ and default to

     ‘ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36’ for bold red

     matched text, magenta file names, green line numbers, green byte

     offsets, cyan separators, and default terminal colors otherwise.

     The deprecated environment variable ‘GREP_COLOR’ is still

     supported, but its setting does not have priority; it defaults to

     ‘01;31’ (bold red) which only covers the color for matched text.

     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 of each file stops 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

     of each file stops on the first match.  (‘-l’ is specified by

     POSIX.)

‘-m NUM’

‘--max-count=NUM’

     Stop after the first NUM selected lines.  If the input is standard

     input from a regular file, and NUM selected lines are output,

     ‘grep’ ensures that the standard input is positioned just after the

     last selected line before exiting, regardless of the presence of

     trailing context lines.  This enables a calling process to resume a

     search.  For example, the following shell script makes use of it:

          while grep -m 1 PATTERN

          do

            echo xxxx

          done < FILE

     But the following probably will not work because a pipe is not a

     regular file:

          # This probably will not work.

          cat FILE |

          while grep -m 1 PATTERN

          do

            echo xxxx

          done

     When ‘grep’ stops after NUM selected 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 matching lines, with

     each such part on a separate output line.  Output lines use the

     same delimiters as input, and delimiters are null bytes if ‘-z’

     (‘--null-data’) is also used (*note Other Options::).

‘-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.(1)  USG-style ‘grep’ also

     lacked ‘-q’ but its ‘-s’ option behaved like GNU ‘grep’’s.

     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.)

   ---------- Footnotes ----------

   (1) Of course, 7th Edition Unix predated POSIX by several years!

?

File: grep.info-t,  Node: Output Line Prefix Control,  Next: Context Line Control,  Prev: General Output Control,  Up: Command-line Options

2.1.4 Output Line Prefix Control

--------------------------------

When several prefix fields are to be output, the order is always file

name, line number, and byte offset, regardless of the order in which

these options were specified.

‘-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

‘-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’.  This may also prepend spaces to output line

     numbers and byte offsets so that lines from a single file all start

     at the same column.

‘-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.

?

File: grep.info-t,  Node: Context Line Control,  Next: File and Directory Selection,  Prev: Output Line Prefix Control,  Up: Command-line Options

2.1.5 Context Line Control

--------------------------

“Context lines” are non-matching lines that are near a matching line.

They are output only if one of the following options are used.

Regardless of how these options are set, ‘grep’ never outputs any given

line more than once.  If the ‘-o’ (‘--only-matching’) option is

specified, these options have no effect and a warning is given upon

their use.

‘-A NUM’

‘--after-context=NUM’

     Print NUM lines of trailing context after matching lines.

‘-B NUM’

‘--before-context=NUM’

     Print NUM lines of leading context before matching lines.

‘-C NUM’

‘-NUM’

‘--context=NUM’

     Print NUM lines of leading and trailing output context.

‘--group-separator=STRING’

     When ‘-A’, ‘-B’ or ‘-C’ are in use, print STRING instead of ‘--’

     between groups of lines.

‘--no-group-separator’

     When ‘-A’, ‘-B’ or ‘-C’ are in use, do not print a separator

     between groups of lines.

   Here are some points about how ‘grep’ chooses the separator to print

between prefix fields and line content:

   • Matching lines normally use ‘:’ as a separator between prefix

     fields and actual line content.

   • Context (i.e., non-matching) lines use ‘-’ instead.

   • When context is not specified, matching lines are simply output one

     right after another.

   • When context is specified, lines that are adjacent in the input

     form a group and are output one right after another, while by

     default a separator appears between non-adjacent groups.

   • The default separator is a ‘--’ line; its presence and appearance

     can be changed with the options above.

   • Each group may contain several matching lines when they are close

     enough to each other that two adjacent groups connect and can merge

     into a single contiguous one.

?

File: grep.info-t,  Node: File and Directory Selection,  Next: Other Options,  Prev: Context Line Control,  Up: Command-line Options

2.1.6 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 a file’s data or metadata indicate that the file contains binary

     data, assume that the file is of type TYPE.  Non-text bytes

     indicate binary data; these are either output bytes that are

     improperly encoded for the current locale (*note Environment

     Variables::), or null input bytes when the ‘-z’ (‘--null-data’)

     option is not given (*note Other Options::).

     By default, TYPE is ‘binary’, and ‘grep’ suppresses output after

     null input binary data is discovered, and suppresses output lines

     that contain improperly encoded data.  When some output is

     suppressed, ‘grep’ follows any output with a one-line message

     saying that a binary file matches.

     If TYPE is ‘without-match’, when ‘grep’ discovers null input binary

     data it assumes that the rest of the file does not match; this is

     equivalent to the ‘-I’ option.

     If TYPE is ‘text’, ‘grep’ processes binary data as if it were text;

     this is equivalent to the ‘-a’ option.

     When TYPE is ‘binary’, ‘grep’ may treat non-text bytes as line

     terminators even without the ‘-z’ (‘--null-data’) option.  This

     means choosing ‘binary’ versus ‘text’ can affect whether a pattern

     matches a file.  For example, when TYPE is ‘binary’ the pattern

     ‘q$’ might match ‘q’ immediately followed by a null byte, even

     though this is not matched when TYPE is ‘text’.  Conversely, when

     TYPE is ‘binary’ the pattern ‘.’ (period) might not match a null

     byte.

     _Warning:_ The ‘-a’ (‘--binary-files=text’) option 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.  On the other hand, when reading files whose text

     encodings are unknown, it can be helpful to use ‘-a’ or to set

     ‘LC_ALL='C'’ in the environment, in order to find more matches even

     if the matches are unsafe for direct display.

‘-D ACTION’

‘--devices=ACTION’

     If an input file is a device, FIFO, or socket, use ACTION to

     process it.  If ACTION is ‘read’, all devices are read just as if

     they were ordinary files.  If ACTION is ‘skip’, devices, FIFOs, and

     sockets are silently skipped.  By default, devices are read if they

     are on the command line or if the ‘-R’ (‘--dereference-recursive’)

     option is used, and are skipped if they are encountered recursively

     and the ‘-r’ (‘--recursive’) option is used.  This option has no

     effect on a file that is read via standard input.

‘-d ACTION’

‘--directories=ACTION’

     If an input file is a directory, use ACTION to process it.  By

     default, ACTION is ‘read’, which means that directories are read

     just as if they were ordinary files (some operating systems and

     file systems disallow this, and will cause ‘grep’ to print error

     messages for every directory or silently skip them).  If ACTION is

     ‘skip’, directories are silently skipped.  If ACTION is ‘recurse’,

     ‘grep’ reads all files under each directory, recursively, following

     command-line symbolic links and skipping other symlinks; this is

     equivalent to the ‘-r’ option.

‘--exclude=GLOB’

     Skip any command-line file with a name suffix that matches the

     pattern GLOB, using wildcard matching; a name suffix is either the

     whole name, or any suffix starting after a ‘/’ and before a

     non-‘/’.  When searching recursively, skip any subfile whose base

     name matches GLOB; the base name is the part after the last ‘/’.  A

     pattern can use ‘*’, ‘?’, and ‘[’...‘]’  as wildcards, and ‘\’ to

     quote a wildcard or backslash character literally.

‘--exclude-from=FILE’

     Skip files whose name matches any of the patterns read from FILE

     (using wildcard matching as described under ‘--exclude’).

‘--exclude-dir=GLOB’

     Skip any command-line directory with a name suffix that matches the

     pattern GLOB.  When searching recursively, skip any subdirectory

     whose base name matches GLOB.  Ignore any redundant trailing

     slashes in GLOB.

‘-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 name matches GLOB, using wildcard matching

     as described under ‘--exclude’.

‘-r’

‘--recursive’

     For each directory operand, read and process all files in that

     directory, recursively.  Follow symbolic links on the command line,

     but skip symlinks that are encountered recursively.  Note that if

     no file operand is given, grep searches the working directory.

     This is the same as the ‘--directories=recurse’ option.

‘-R’

‘--dereference-recursive’

     For each directory operand, read and process all files in that

     directory, recursively, following all symbolic links.

?

File: grep.info-t,  Node: Other Options,  Prev: File and Directory Selection,  Up: Command-line Options

2.1.7 Other Options

-------------------

‘--line-buffered’

     Use line buffering on output.  This can cause a performance

     penalty.

‘-U’

‘--binary’

     On platforms that distinguish between text and binary I/O, use the

     latter when reading and writing files other than the user’s

     terminal, so that all input bytes are read and written as-is.  This

     overrides the default behavior where ‘grep’ follows the operating

     system’s advice whether to use text or binary I/O.  On MS-Windows

     when ‘grep’ uses text I/O it reads a carriage return–newline pair

     as a newline and a Control-Z as end-of-file, and it writes a

     newline as a carriage return–newline pair.

     When using text I/O ‘--byte-offset’ (‘-b’) counts and

     ‘--binary-files’ heuristics apply to input data after text-I/O

     processing.  Also, the ‘--binary-files’ heuristics need not agree

     with the ‘--binary’ option; that is, they may treat the data as

     text even if ‘--binary’ is given, or vice versa.  *Note File and

     Directory Selection::.

     This option has no effect on GNU and other POSIX-compatible

     platforms, which do not distinguish text from binary I/O.

‘-z’

‘--null-data’

     Treat input and output data as sequences 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.

?

File: grep.info-t,  Node: Environment Variables,  Next: Exit Status,  Prev: Command-line Options,  Up: Invoking

2.2 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’, and ‘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_COLLATE’ is set to ‘pt_BR’,

then the Brazilian Portuguese locale is used for the ‘LC_COLLATE’

category.  As a special case for ‘LC_MESSAGES’ only, the environment

variable ‘LANGUAGE’ can contain a colon-separated list of languages that

overrides the three environment variables that ordinarily specify 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). The

shell command ‘locale -a’ lists locales that are currently available.

   Many of the environment variables in the following list let you

control highlighting using Select Graphic Rendition (SGR) commands

interpreted by the terminal or terminal emulator.  (See the section in

the documentation of your text terminal for permitted values and their

meanings 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.

   The two-letter names used in the ‘GREP_COLORS’ environment variable

(and some of the others) refer to terminal “capabilities,” the ability

of a terminal to highlight text, or change its color, and so on.  These

capabilities are stored in an online database and accessed by the

‘terminfo’ library.

‘GREP_OPTIONS’

     This variable specifies default options to be placed in front of

     any explicit options.  As this causes problems when writing

     portable scripts, this feature will be removed in a future release

     of ‘grep’, and ‘grep’ warns if it is used.  Please use an alias or

     script instead.  For example, if ‘grep’ is in the directory

     ‘/usr/bin’ you can prepend ‘$HOME/bin’ to your ‘PATH’ and create an

     executable script ‘$HOME/bin/grep’ containing the following:

          #! /bin/sh

          export PATH=/usr/bin

          exec grep --color=auto --devices=skip "$@"

‘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’

     This variable specifies the colors and other attributes used to

     highlight various parts of the output.  Its value is a

     colon-separated list of ‘terminfo’ 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 used only when the ‘-v’ command-line option is

          omitted.)  The effect of the ‘sl=’ (or ‘cx=’ if ‘rv’)

          capability remains active when this takes effect.  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 used only when the ‘-v’ command-line option is

          specified.)  The effect of the ‘cx=’ (or ‘sl=’ if ‘rv’)

          capability remains active when this takes effect.  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.

‘LC_ALL’

‘LC_COLLATE’

‘LANG’

     These variables specify the locale for the ‘LC_COLLATE’ category,

     which might affect how range expressions like ‘[a-z]’ are

     interpreted.

‘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.  This category also determines the character encoding,

     that is, whether text is encoded in UTF-8, ASCII, or some other

     encoding.  In the ‘C’ or ‘POSIX’ locale, all characters are encoded

     as a single byte and every byte is a valid character.

‘LANGUAGE’

‘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, ‘POSIXLY_CORRECT’ disables special

     handling of an invalid bracket expression.  *Note

     invalid-bracket-expr::.

‘_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.

?

File: grep.info-t,  Node: Exit Status,  Next: grep Programs,  Prev: Environment Variables,  Up: Invoking

2.3 Exit Status

===============

Normally the exit status is 0 if a line is selected, 1 if no lines were

selected, and 2 if an error occurred.  However, if the ‘-q’ or ‘--quiet’

or ‘--silent’ option is used and a line is selected, the exit status is

0 even if an error occurred.  Other ‘grep’ implementations may exit with

status greater than 2 on error.

?

File: grep.info-t,  Node: grep Programs,  Prev: Exit Status,  Up: Invoking

2.4 ‘grep’ Programs

===================

‘grep’ searches the named input files for lines containing a match to

the given pattern.  By default, ‘grep’ prints the matching lines.  A

file named ‘-’ stands for standard input.  If no input is specified,

‘grep’ searches the working directory ‘.’ if given a command-line option

specifying recursion; otherwise, ‘grep’ searches standard input.  There

are four major variants of ‘grep’, controlled by the following options.

‘-G’

‘--basic-regexp’

     Interpret the pattern as a basic regular expression (BRE). This is

     the default.

‘-E’

‘--extended-regexp’

     Interpret the pattern as an extended regular expression (ERE).

     (‘-E’ is specified by POSIX.)

‘-F’

‘--fixed-strings’

     Interpret the pattern as a list of fixed strings (instead of

     regular expressions), separated by newlines, any of which is to be

     matched.  (‘-F’ is specified by POSIX.)

‘-P’

‘--perl-regexp’

     Interpret the pattern as a Perl-compatible regular expression

     (PCRE). This is experimental, particularly when combined with the

     ‘-z’ (‘--null-data’) option, and ‘grep -P’ may warn of

     unimplemented features.  *Note Other Options::.

   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.

?

File: grep.info-t,  Node: Regular Expressions,  Next: Usage,  Prev: Invoking,  Up: Top

3 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 (BRE), extended (ERE), and Perl-compatible (PCRE). In GNU

‘grep’, there is no difference in available functionality between the

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-compatible regular expressions give

additional functionality, and are documented in the pcresyntax(3) and

pcrepattern(3) manual pages, but work only if PCRE is available in the

system.

* Menu:

* Fundamental Structure::

* Character Classes and Bracket Expressions::

* The Backslash Character and Special Expressions::

* Anchoring::

* Back-references and Subexpressions::

* Basic vs Extended::

?

File: grep.info-t,  Node: Fundamental Structure,  Next: Character Classes and Bracket Expressions,  Up: Regular Expressions

3.1 Fundamental Structure

=========================

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.

   A regular expression may be followed by one of several repetition

operators:

‘.’

     The period ‘.’ matches any single character.

‘?’

     The preceding item is optional and will be 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