| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
grep grep comes with a rich set of options from POSIX.2 and GNU
extensions.
Suppress normal output; instead print a count of matching lines for each input file. With the `-v', `--invert-match' option, count non-matching lines.
Use pattern as the pattern; useful to protect patterns beginning with a `-'.
Obtain patterns from file, one per line. The empty file contains zero patterns, and therefore matches nothing.
Ignore case distinctions in both the pattern and the input files.
Suppress normal output; instead print the name of each input file from which output would normally have been printed. The scanning of every file will stop on the first match.
Prefix each line of output with the line number within its input file.
Print only the part of matching lines that actually matches pattern.
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.
Suppress error messages about nonexistent or unreadable files.
Portability note: unlike GNU grep, traditional
grep did not conform to POSIX.2, because traditional
grep lacked a `-q' option and its `-s' option behaved
like GNU grep's `-q' option. Shell scripts intended
to be portable to traditional grep should avoid both
`-q' and `-s' and should redirect
output to `/dev/null' instead.
Invert the sense of matching, to select non-matching lines.
Select only those matches that exactly match the whole line.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Print num lines of trailing context after matching lines.
Print num lines of leading context before matching lines.
Print num lines of output context.
The matching string is surrounded by the marker specify in GREP_COLOR. WHEN may be `never', `always', or `auto'.
Same as `--context=num' lines of leading and trailing context. However, grep will never print any given line more than once.
Print the version number of grep to the standard output stream.
This version number should be included in all bug reports.
Print a usage message briefly summarizing these command-line options and the bug-reporting address, then exit.
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: `--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.
Print the byte offset within the input file before each line of output.
When grep runs on MS-DOS or MS-Windows, the printed
byte offsets
depend on whether the `-u' (`--unix-byte-offsets') option is
used; see below.
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, FIFOs and sockets are silently skipped.
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 filesystems 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; this is equivalent to the `-r' option.
Print the filename for each match.
Suppress the prefixing of filenames on output when multiple files are searched.
Set the line buffering policy, this can be a performance penality.
Displays input actually coming from standard input as input coming from file
LABEL. This is especially useful for tools like zgrep, e.g.
gzip -cd foo.gz |grep --label=foo something
Suppress normal output; instead print the name of each input file from which no output would normally have been printed. The scanning of every file will stop on the first match.
Process a binary file as if it were text; this is equivalent to the `--binary-files=text' option.
Process a binary file as if it did not contain matching data; this is equivalent to the `--binary-files=without-match' option.
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.
For each directory mentioned in the command line, read and process all files in that directory, recursively. This is the same as the `--directories=recurse' option.
When processing directories recursively, only files matching file_pattern will be search.
When processing directories recursively, skip files matching file_pattern.
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. 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 matching lines, it outputs
any trailing context lines. Since context does not include matching
lines, grep will stop when it encounters another matching line.
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.
Obsolete synonym for `-i'.
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.
Report Unix-style byte offsets. This switch causes
grep to report byte offsets as if the file were Unix style
text file, i.e., the byte offsets ignore the CR characters which were
stripped. 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.
If possible, use the mmap system call to read input, instead of
the default read system call. In some situations, `--mmap'
yields better performance. However, `--mmap' can cause undefined
behavior (including core dumps) if an input file shrinks while
grep is operating, or if an I/O error occurs.
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.
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.
Several additional options control which variant of the grep
matching engine is used. See section grep programs.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Grep's behavior is affected by the following environment variables.
A locale 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_MESSAGES
is set to `pt_BR', then Brazilian Portuguese is used for the
LC_MESSAGES locale. The C locale is used if none of these
environment variables are set, or if the locale catalog is not
installed, or if grep was not compiled with national language
support (NLS).
GREP_OPTIONSThis 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_COLORThis variable specifies the surrounding markers use to highlight the matching text. The default is control ascii red.
LC_ALL LC_COLLATE LANGThese variables specify the LC_COLLATE locale, which determines
the collating sequence used to interpret range expressions like
`[a-z]'.
LC_ALL LC_CTYPE LANGThese variables specify the LC_CTYPE locale, which determines the
type of characters, e.g., which characters are whitespace.
LC_ALL LC_MESSAGES LANGThese variables specify the LC_MESSAGES locale, which determines
the language that grep uses for messages. The default C
locale uses American English messages.
POSIXLY_CORRECTIf set, grep behaves as POSIX.2 requires; otherwise,
grep behaves more like other GNU programs. POSIX.2
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.2 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.
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by System Administrator on April, 1 2005 using texi2html 1.70.