\input texinfo  @c -*-texinfo-*-

@c %**start of header

@setfilename grep.info

@include version.texi

@settitle GNU Grep @value{VERSION}

@c Combine indices.

@syncodeindex ky cp

@syncodeindex pg cp

@syncodeindex tp cp

@defcodeindex op

@syncodeindex op cp

@syncodeindex vr cp

@c %**end of header

@documentencoding UTF-8

@copying

This manual is for @command{grep}, a pattern matching engine.

Copyright @copyright{} 1999-2002, 2005, 2008-2017 Free Software Foundation,

Inc.

@quotation

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

@end quotation

@end copying

@dircategory Text creation and manipulation

@direntry

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

@end direntry

@titlepage

@title GNU Grep: Print lines matching a pattern

@subtitle version @value{VERSION}, @value{UPDATED}

@author Alain Magloire et al.

@page

@vskip 0pt plus 1filll

@insertcopying

@end titlepage

@contents

@ifnottex

@node Top

@top grep

@command{grep} prints lines that contain a match for a pattern.

This manual is for version @value{VERSION} of GNU Grep.

@insertcopying

@end ifnottex

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

@end menu

@node Introduction

@chapter Introduction

@cindex searching for a pattern

@command{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 @command{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,

@command{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.

@node Invoking

@chapter Invoking @command{grep}

The general synopsis of the @command{grep} command line is

@example

grep @var{options} @var{pattern} @var{input_file_names}

@end example

@noindent

There can be zero or more @var{options}.

@var{pattern} will only be seen as such

(and not as an @var{input_file_name})

if it wasn't already specified within @var{options}

(by using the @samp{-e@ @var{pattern}}

or @samp{-f@ @var{file}} options).

There can be zero or more @var{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 @command{grep}.

* grep Programs::               @command{grep} programs.

@end menu

@node Command-line Options

@section Command-line Options

@command{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::

@end menu

Several additional options control

which variant of the @command{grep} matching engine is used.

@xref{grep Programs}.

@node Generic Program Information

@subsection Generic Program Information

@table @option

@item --help

@opindex --help

@cindex usage summary, printing

Print a usage message briefly summarizing the command-line options

and the bug-reporting address, then exit.

@item -V

@itemx --version

@opindex -V

@opindex --version

@cindex version, printing

Print the version number of @command{grep} to the standard output stream.

This version number should be included in all bug reports.

@end table

@node Matching Control

@subsection Matching Control

@table @option

@item -e @var{pattern}

@itemx --regexp=@var{pattern}

@opindex -e

@opindex --regexp=@var{pattern}

@cindex pattern list

Use @var{pattern} as the pattern.

If this option is used multiple times or is combined with the

@option{-f} (@option{--file}) option, search for all patterns given.

(@option{-e} is specified by POSIX.)

@item -f @var{file}

@itemx --file=@var{file}

@opindex -f

@opindex --file

@cindex pattern from file

Obtain patterns from @var{file}, one per line.

If this option is used multiple times or is combined with the

@option{-e} (@option{--regexp}) option, search for all patterns given.

The empty file contains zero patterns, and therefore matches nothing.

(@option{-f} is specified by POSIX.)

@item -i

@itemx -y

@itemx --ignore-case

@opindex -i

@opindex -y

@opindex --ignore-case

@cindex case insensitive search

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.

@option{-y} is an obsolete synonym that is provided for compatibility.

(@option{-i} is specified by POSIX.)

@item -v

@itemx --invert-match

@opindex -v

@opindex --invert-match

@cindex invert matching

@cindex print non-matching lines

Invert the sense of matching, to select non-matching lines.

(@option{-v} is specified by POSIX.)

@item -w

@itemx --word-regexp

@opindex -w

@opindex --word-regexp

@cindex matching whole words

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 @option{-x} is also specified.

@item -x

@itemx --line-regexp

@opindex -x

@opindex --line-regexp

@cindex match the whole line

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 @samp{^} and @samp{$}.

(@option{-x} is specified by POSIX.)

@end table

@node General Output Control

@subsection General Output Control

@table @option

@item -c

@itemx --count

@opindex -c

@opindex --count

@cindex counting lines

Suppress normal output;

instead print a count of matching lines for each input file.

With the @option{-v} (@option{--invert-match}) option,

count non-matching lines.

(@option{-c} is specified by POSIX.)

@item --color[=@var{WHEN}]

@itemx --colour[=@var{WHEN}]

@opindex --color

@opindex --colour

@cindex highlight, color, colour

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 @env{GREP_COLORS}

and default to @samp{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 @env{GREP_COLOR} is still supported,

but its setting does not have priority;

it defaults to @samp{01;31} (bold red)

which only covers the color for matched text.

@var{WHEN} is @samp{never}, @samp{always}, or @samp{auto}.

@item -L

@itemx --files-without-match

@opindex -L

@opindex --files-without-match

@cindex files which don't 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.

@item -l

@itemx --files-with-matches

@opindex -l

@opindex --files-with-matches

@cindex names of matching files

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.

(@option{-l} is specified by POSIX.)

@item -m @var{num}

@itemx --max-count=@var{num}

@opindex -m

@opindex --max-count

@cindex max-count

Stop after the first @var{num} selected lines.

If the input is standard input from a regular file,

and @var{num} selected lines are output,

@command{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:

@example

while grep -m 1 PATTERN

do

  echo xxxx

done < FILE

@end example

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

file:

@example

# This probably will not work.

cat FILE |

while grep -m 1 PATTERN

do

  echo xxxx

done

@end example

@cindex context lines

When @command{grep} stops after @var{num} selected lines,

it outputs any trailing context lines.

When the @option{-c} or @option{--count} option is also used,

@command{grep} does not output a count greater than @var{num}.

When the @option{-v} or @option{--invert-match} option is also used,

@command{grep} stops after outputting @var{num} non-matching lines.

@item -o

@itemx --only-matching

@opindex -o

@opindex --only-matching

@cindex 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 @option{-z} (@option{--null-data}) is also used (@pxref{Other

Options}).

@item -q

@itemx --quiet

@itemx --silent

@opindex -q

@opindex --quiet

@opindex --silent

@cindex 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 @option{-s} or @option{--no-messages} option.

(@option{-q} is specified by POSIX.)

@item -s

@itemx --no-messages

@opindex -s

@opindex --no-messages

@cindex suppress error messages

Suppress error messages about nonexistent or unreadable files.

Portability note:

unlike GNU @command{grep},

7th Edition Unix @command{grep} did not conform to POSIX,

because it lacked @option{-q}

and its @option{-s} option behaved like

GNU @command{grep}'s @option{-q} option.@footnote{Of course, 7th Edition

Unix predated POSIX by several years!}

USG-style @command{grep} also lacked @option{-q}

but its @option{-s} option behaved like GNU @command{grep}'s.

Portable shell scripts should avoid both

@option{-q} and @option{-s} and should redirect

standard and error output to @file{/dev/null} instead.

(@option{-s} is specified by POSIX.)

@end table

@node Output Line Prefix Control

@subsection 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.

@table @option

@item -b

@itemx --byte-offset

@opindex -b

@opindex --byte-offset

@cindex byte offset

Print the 0-based byte offset within the input file

before each line of output.

If @option{-o} (@option{--only-matching}) is specified,

print the offset of the matching part itself.

@item -H

@itemx --with-filename

@opindex -H

@opindex --with-filename

@cindex with filename prefix

Print the file name for each match.

This is the default when there is more than one file to search.

@item -h

@itemx --no-filename

@opindex -h

@opindex --no-filename

@cindex no filename prefix

Suppress the prefixing of file names on output.

This is the default when there is only one file

(or only standard input) to search.

@item --label=@var{LABEL}

@opindex --label

@cindex changing name of standard input

Display input actually coming from standard input

as input coming from file @var{LABEL}.  This is

especially useful when implementing tools like

@command{zgrep}; e.g.:

@example

gzip -cd foo.gz | grep --label=foo -H something

@end example

@item -n

@itemx --line-number

@opindex -n

@opindex --line-number

@cindex line numbering

Prefix each line of output with the 1-based line number within its input file.

(@option{-n} is specified by POSIX.)

@item -T

@itemx --initial-tab

@opindex -T

@opindex --initial-tab

@cindex tab-aligned content lines

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:

@option{-H}, @option{-n}, and @option{-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.

@item -Z

@itemx --null

@opindex -Z

@opindex --null

@cindex zero-terminated file names

Output a zero byte (the ASCII NUL character)

instead of the character that normally follows a file name.

For example,

@samp{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

@samp{find -print0}, @samp{perl -0}, @samp{sort -z}, and @samp{xargs -0}

to process arbitrary file names,

even those that contain newline characters.

@end table

@node Context Line Control

@subsection Context Line Control

@cindex context lines

@dfn{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,

@command{grep} never outputs any given line more than once.

If the @option{-o} (@option{--only-matching}) option is specified,

these options have no effect and a warning is given upon their use.

@table @option

@item -A @var{num}

@itemx --after-context=@var{num}

@opindex -A

@opindex --after-context

@cindex after context

@cindex context lines, after match

Print @var{num} lines of trailing context after matching lines.

@item -B @var{num}

@itemx --before-context=@var{num}

@opindex -B

@opindex --before-context

@cindex before context

@cindex context lines, before match

Print @var{num} lines of leading context before matching lines.

@item -C @var{num}

@itemx -@var{num}

@itemx --context=@var{num}

@opindex -C

@opindex --context

@opindex -@var{num}

@cindex context lines

Print @var{num} lines of leading and trailing output context.

@item --group-separator=@var{string}

@opindex --group-separator

@cindex group separator

When @option{-A}, @option{-B} or @option{-C} are in use,

print @var{string} instead of @option{--} between groups of lines.

@item --no-group-separator

@opindex --group-separator

@cindex group separator

When @option{-A}, @option{-B} or @option{-C} are in use,

do not print a separator between groups of lines.

@end table

Here are some points about how @command{grep} chooses

the separator to print between prefix fields and line content:

@itemize @bullet

@item

Matching lines normally use @samp{:} as a separator

between prefix fields and actual line content.

@item

Context (i.e., non-matching) lines use @samp{-} instead.

@item

When context is not specified,

matching lines are simply output one right after another.

@item

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.

@item

The default separator

is a @samp{--} line; its presence and appearance

can be changed with the options above.

@item

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.

@end itemize

@node File and Directory Selection

@subsection File and Directory Selection

@table @option

@item -a

@itemx --text

@opindex -a

@opindex --text

@cindex suppress binary data

@cindex binary files

Process a binary file as if it were text;

this is equivalent to the @samp{--binary-files=text} option.

@item --binary-files=@var{type}

@opindex --binary-files

@cindex binary files

If a file's data or metadata

indicate that the file contains binary data,

assume that the file is of type @var{type}.

Non-text bytes indicate binary data; these are either output bytes that are

improperly encoded for the current locale (@pxref{Environment

Variables}), or null input bytes when the

@option{-z} (@option{--null-data}) option is not given (@pxref{Other

Options}).

By default, @var{type} is @samp{binary}, and @command{grep}

suppresses output after null input binary data is discovered,

and suppresses output lines that contain improperly encoded data.

When some output is suppressed, @command{grep} follows any output

with a one-line message saying that a binary file matches.

If @var{type} is @samp{without-match},

when @command{grep} discovers null input binary data

it assumes that the rest of the file does not match;

this is equivalent to the @option{-I} option.

If @var{type} is @samp{text},

@command{grep} processes binary data as if it were text;

this is equivalent to the @option{-a} option.

When @var{type} is @samp{binary}, @command{grep} may treat non-text

bytes as line terminators even without the @option{-z}

(@option{--null-data}) option.  This means choosing @samp{binary}

versus @samp{text} can affect whether a pattern matches a file.  For

example, when @var{type} is @samp{binary} the pattern @samp{q$} might

match @samp{q} immediately followed by a null byte, even though this

is not matched when @var{type} is @samp{text}.  Conversely, when

@var{type} is @samp{binary} the pattern @samp{.} (period) might not

match a null byte.

@emph{Warning:} The @option{-a} (@option{--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 @option{-a} or to set

@samp{LC_ALL='C'} in the environment, in order to find more matches

even if the matches are unsafe for direct display.

@item -D @var{action}

@itemx --devices=@var{action}

@opindex -D

@opindex --devices

@cindex device search

If an input file is a device, FIFO, or socket, use @var{action} to process it.

If @var{action} is @samp{read},

all devices are read just as if they were ordinary files.

If @var{action} is @samp{skip},

devices, FIFOs, and sockets are silently skipped.

By default, devices are read if they are on the command line or if the

@option{-R} (@option{--dereference-recursive}) option is used, and are

skipped if they are encountered recursively and the @option{-r}

(@option{--recursive}) option is used.

This option has no effect on a file that is read via standard input.

@item -d @var{action}

@itemx --directories=@var{action}

@opindex -d

@opindex --directories

@cindex directory search

@cindex symbolic links

If an input file is a directory, use @var{action} to process it.

By default, @var{action} is @samp{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 @command{grep}

to print error messages for every directory or silently skip them).

If @var{action} is @samp{skip}, directories are silently skipped.

If @var{action} is @samp{recurse},

@command{grep} reads all files under each directory, recursively,

following command-line symbolic links and skipping other symlinks;

this is equivalent to the @option{-r} option.

@item --exclude=@var{glob}

@opindex --exclude

@cindex exclude files

@cindex searching directory trees

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

@var{glob}, using wildcard matching; a name suffix is either the whole

name, or any suffix starting after a @samp{/} and before a

non-@samp{/}.  When searching recursively, skip any subfile whose base

name matches @var{glob}; the base name is the part after the last

@samp{/}.  A pattern can use

@samp{*}, @samp{?}, and @samp{[}...@samp{]} as wildcards,

and @code{\} to quote a wildcard or backslash character literally.

@item --exclude-from=@var{file}

@opindex --exclude-from

@cindex exclude files

@cindex searching directory trees

Skip files whose name matches any of the patterns

read from @var{file} (using wildcard matching as described

under @option{--exclude}).

@item --exclude-dir=@var{glob}

@opindex --exclude-dir

@cindex exclude directories

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

pattern @var{glob}.  When searching recursively, skip any subdirectory

whose base name matches @var{glob}.  Ignore any redundant trailing

slashes in @var{glob}.

@item -I

Process a binary file as if it did not contain matching data;

this is equivalent to the @samp{--binary-files=without-match} option.

@item --include=@var{glob}

@opindex --include

@cindex include files

@cindex searching directory trees

Search only files whose name matches @var{glob},

using wildcard matching as described under @option{--exclude}.

@item -r

@itemx --recursive

@opindex -r

@opindex --recursive

@cindex recursive search

@cindex searching directory trees

@cindex symbolic links

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 @samp{--directories=recurse} option.

@item -R

@itemx --dereference-recursive

@opindex -R

@opindex --dereference-recursive

@cindex recursive search

@cindex searching directory trees

@cindex symbolic links

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

directory, recursively, following all symbolic links.

@end table

@node Other Options

@subsection Other Options

@table @option

@item --line-buffered

@opindex --line-buffered

@cindex line buffering

Use line buffering on output.

This can cause a performance penalty.

@item -U

@itemx --binary

@opindex -U

@opindex --binary

@cindex MS-Windows binary I/O

@cindex binary I/O

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 @command{grep}

follows the operating system's advice whether to use text or binary

I/O@.  On MS-Windows when @command{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 @option{--byte-offset} (@option{-b}) counts and

@option{--binary-files} heuristics apply to input data after text-I/O

processing.  Also, the @option{--binary-files} heuristics need not agree

with the @option{--binary} option; that is, they may treat the data as

text even if @option{--binary} is given, or vice versa.

@xref{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.

@item -z

@itemx --null-data

@opindex -z

@opindex --null-data

@cindex zero-terminated lines

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 @option{-Z} or @option{--null} option,

this option can be used with commands like

@samp{sort -z} to process arbitrary file names.

@end table

@node Environment Variables

@section Environment Variables

The behavior of @command{grep} is affected

by the following environment variables.

@vindex LANGUAGE @r{environment variable}

@vindex LC_ALL @r{environment variable}

@vindex LC_MESSAGES @r{environment variable}

@vindex LANG @r{environment variable}

The locale for category @w{@code{LC_@var{foo}}}

is specified by examining the three environment variables

@env{LC_ALL}, @w{@env{LC_@var{foo}}}, and @env{LANG},

in that order.

The first of these variables that is set specifies the locale.

For example, if @env{LC_ALL} is not set,

but @env{LC_COLLATE} is set to @samp{pt_BR},

then the Brazilian Portuguese locale is used

for the @env{LC_COLLATE} category.

As a special case for @env{LC_MESSAGES} only, the environment variable

@env{LANGUAGE} can contain a colon-separated list of languages that

overrides the three environment variables that ordinarily specify

the @env{LC_MESSAGES} category.

The @samp{C} locale is used if none of these environment variables are set,

if the locale catalog is not installed,

or if @command{grep} was not compiled

with national language support (NLS).

The shell command @code{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.

@command{grep} takes care of assembling the result

into a complete SGR sequence (@samp{\33[}...@samp{m}).

Common values to concatenate include

@samp{1} for bold,

@samp{4} for underline,

@samp{5} for blink,

@samp{7} for inverse,

@samp{39} for default foreground color,

@samp{30} to @samp{37} for foreground colors,

@samp{90} to @samp{97} for 16-color mode foreground colors,

@samp{38;5;0} to @samp{38;5;255}

for 88-color and 256-color modes foreground colors,

@samp{49} for default background color,

@samp{40} to @samp{47} for background colors,

@samp{100} to @samp{107} for 16-color mode background colors,

and @samp{48;5;0} to @samp{48;5;255}

for 88-color and 256-color modes background colors.

The two-letter names used in the @env{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 @code{terminfo} library.

@cindex environment variables

@table @env

@item GREP_OPTIONS

@vindex GREP_OPTIONS @r{environment variable}

@cindex default options environment variable

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 @command{grep}, and @command{grep}

warns if it is used.  Please use an alias or script instead.

For example, if @command{grep} is in the directory @samp{/usr/bin} you

can prepend @file{$HOME/bin} to your @env{PATH} and create an

executable script @file{$HOME/bin/grep} containing the following:

@example

#! /bin/sh

export PATH=/usr/bin

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

@end example

@item GREP_COLOR

@vindex GREP_COLOR @r{environment variable}

@cindex highlight markers

This variable specifies the color used to highlight matched (non-empty) text.

It is deprecated in favor of @env{GREP_COLORS}, but still supported.

The @samp{mt}, @samp{ms}, and @samp{mc} capabilities of @env{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 @option{-v} command-line option is omitted,

or a context line when @option{-v} is specified).

The default is @samp{01;31},

which means a bold red foreground text on the terminal's default background.

@item GREP_COLORS

@vindex GREP_COLORS @r{environment variable}

@cindex highlight markers

This variable specifies the colors and other attributes

used to highlight various parts of the output.