2.1 GNU Extensions

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

`--context=num'

Print num lines of output context.

`--colour[=WHEN]'

`--color[=WHEN]'

The matching string is surrounded by the marker specify in GREP_COLOR. WHEN may be `never', `always', or `auto'.

`-num'

Same as `--context=num' lines of leading and trailing context. However, grep will never print any given line more than once.

`-V'

`--version'

Print the version number of grep to the standard output stream. This version number should be included in all bug reports.

`--help'

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

`--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: `--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.

`-b'

`--byte-offset'

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.

`-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, FIFOs and sockets are silently skipped.

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

`-H'

`--with-filename'

Print the filename for each match.

`-h'

`--no-filename'

Suppress the prefixing of filenames on output when multiple files are searched.

`--line-buffered'

Set the line buffering policy, this can be a performance penality.

`--label=LABEL'

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

`-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 every file will stop on the first match.

`-a'

`--text'

Process a binary file as if it were text; this is equivalent to the `--binary-files=text' option.

`-I'

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

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

`-r'

`-R'

`--recursive'

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.

`--include=file_pattern'

When processing directories recursively, only files matching file_pattern will be search.

`--exclude=file_pattern'

When processing directories recursively, skip files matching file_pattern.

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

`-y'

Obsolete synonym for `-i'.

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

`-u'

`--unix-byte-offsets'

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.

`--mmap'

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.

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

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

Several additional options control which variant of the grep matching engine is used. See section 4. grep programs.