Table of Contents
- 2 Invoking
grep
- 2.1 Command-line Options
- 3 Regular Expressions
- 6 Reporting bugs
- 7 Copying
Problem: You need to reverse the meaning of a search you're performing with the grep command. For instance, you've been searching for pepperoni pizza orders like this: grep pepperoni pizza-orders.txt and now you need to find all orders that don't have pepperoni. Just add the -v switch to your grep search command, like this. 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 32 KB 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 ^.
grep
prints lines that contain a match for one or more patterns.This manual is for version 3.3 of GNU Grep.
This manual is for
grep
, a pattern matching engine.Copyright © 1999-2002, 2005, 2008-2018 Free Software Foundation,Inc.
Permission is granted to copy, distribute and/or modify this documentunder the terms of the GNU Free Documentation License, Version 1.3 orany later version published by the Free Software Foundation; with noInvariant Sections, with no Front-Cover Texts, and with no Back-CoverTexts. A copy of the license is included in the section entitled“GNU Free Documentation License”.
• 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. |
Next: Invoking, Previous: Top, Up: Top [Contents][Index]
1 Introduction
Given one or more patterns,
grep
searches input filesfor matches to the patterns.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.Next: Regular Expressions, Previous: Introduction, Up: Top [Contents][Index]
2 Invoking grep
The general synopsis of the
grep
command line isThere can be zero or more option arguments, and zero or morefile arguments. The patterns argument contains one ormore patterns separated by newlines, and is omitted when patterns aregiven via the ‘-e patterns’ or ‘-f file’options.
• 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. |
Next: Environment Variables, Up: Invoking [Contents][Index]
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 suchto facilitate POSIX-portable programming.A few option names are providedfor compatibility with older or more exotic implementations.• Generic Program Information: |
• Matching Control: |
• General Output Control: |
• Output Line Prefix Control: |
• Context Line Control: |
• File and Directory Selection: |
• Other Options: |
Several additional options controlwhich variant of the
grep
matching engine is used.See grep Programs.Next: Matching Control, Up: Command-line Options [Contents][Index]
2.1.1 Generic Program Information
Print a usage message briefly summarizing the command-line optionsand the bug-reporting address, then exit.
Print the version number of
grep
to the standard output stream.This version number should be included in all bug reports.Next: General Output Control, Previous: Generic Program Information, Up: Command-line Options [Contents][Index]
2.1.2 Matching Control
Use patterns as one or more patterns; newlines withinpatterns separate each pattern from the next.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.)
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.)
Ignore case distinctions, so that characters that differ only in casematch each other. Although this is straightforward when lettersdiffer in case only via lowercase-uppercase pairs, the behavior isunspecified in other situations. For example, uppercase “S” has anunusual lowercase counterpart “ſ” (Unicode character U+017F, LATINSMALL LETTER LONG S) in many locales, and it is unspecified whetherthis unusual character matches “S” or “s” even though uppercasingit yields “S”. Another example: the lowercase German letter “ß”(U+00DF, LATIN SMALL LETTER SHARP S) is normally capitalized as thetwo-character string “SS” but it does not match “SS”, and it mightnot match the uppercase letter “ẞ” (U+1E9E, LATIN CAPITAL LETTERSHARP S) even though lowercasing the latter yields the former.
-y is an obsolete synonym that is provided for compatibility.(-i is specified by POSIX.)
Invert the sense of matching, to select non-matching lines.(-v is specified by POSIX.)
Select only those lines containing matches that form whole words.The test is that the matching substring must eitherbe at the beginning of the line,or preceded by a non-word constituent character.Similarly,it must be either at the end of the lineor 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.
Because the -w option can match a substring that does notbegin and end with word constituents, it differs from surrounding aregular expression with ‘<’ and ‘>’. For example, although‘grep -w @’ matches a line containing only ‘@’, ‘grep'<@>'’ cannot match any line because ‘@’ is not aword constituent. See The Backslash Character and Special Expressions.
Select only those matches that exactly match the whole line.For regular expression patterns, this is like parenthesizing eachpattern and then surrounding it with ‘^’ and ‘$’.(-x is specified by POSIX.)
Next: Output Line Prefix Control, Previous: Matching Control, Up: Command-line Options [Contents][Index]
2.1.3 General Output Control
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.)
Surround the matched (non-empty) strings, matching lines, context lines,file names, line numbers, byte offsets, and separators (for fields andgroups of context lines) with escape sequences to display them in coloron 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’.Suppress normal output;instead print the name of each input file from whichno output would normally have been printed.The scanning of each file stops on the first match.
Suppress normal output;instead print the name of each input file from whichoutput would normally have been printed.The scanning of each file stops on the first match.(-l is specified by POSIX.)
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 positionedjust 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:But the following probably will not work because a pipe is not a regularfile:
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.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 nullbytes if -z (--null-data) is also used (see Other Options).
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.)
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 -qand its -s option behaved likeGNU grep
’s -q option.1USG-style grep
also lacked -qbut its -s option behaved like GNU grep
’s.Portable shell scripts should avoid both-q and -s and should redirectstandard and error output to /dev/null instead.(-s is specified by POSIX.)Next: Context Line Control, Previous: General Output Control, Up: Command-line Options [Contents][Index]
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.
Print the 0-based byte offset within the input filebefore each line of output.If -o (--only-matching) is specified,print the offset of the matching part itself.
Print the file name for each match.This is the default when there is more than one file to search.
Suppress the prefixing of file names on output.This is the default when there is only one file(or only standard input) to search.
Display input actually coming from standard inputas input coming from file LABEL. This isespecially useful when implementing tools like
zgrep
; e.g.:Prefix each line of output with the 1-based line number within its input file.(-n is specified by POSIX.)
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 offsetsso that lines from a single file all start at the same column.
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 nameinstead 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.
Next: File and Directory Selection, Previous: Output Line Prefix Control, Up: Command-line Options [Contents][Index]
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.Print num lines of trailing context after matching lines.
Print num lines of leading context before matching lines.
Print num lines of leading and trailing output context.
When -A, -B or -C are in use,print string instead of -- between groups of lines.
When -A, -B or -C are in use,do not print a separator between groups of lines.
Here are some points about how
grep
choosesthe separator to print between prefix fields and line content:- Matching lines normally use ‘:’ as a separatorbetween 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 groupand are output one right after another, whileby default a separator appears between non-adjacent groups.
- The default separatoris a ‘--’ line; its presence and appearancecan be changed with the options above.
- Each group may containseveral matching lines when they are close enough to each otherthat two adjacent groups connect and can merge into a singlecontiguous one.
Next: Other Options, Previous: Context Line Control, Up: Command-line Options [Contents][Index]
2.1.6 File and Directory Selection
Process a binary file as if it were text;this is equivalent to the ‘--binary-files=text’ option.
If a file’s data or metadataindicate 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 areimproperly encoded for the current locale (see Environment Variables), or null input bytes when the-z (--null-data) option is not given (see 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 outputwith a one-line message saying that a binary file matches.If type is ‘without-match’,when
grep
discovers null input binary datait 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-textbytes as line terminators even without the -z(--null-data) option. This means choosing ‘binary’versus ‘text’ can affect whether a pattern matches a file. Forexample, when type is ‘binary’ the pattern ‘q$’ mightmatch ‘q’ immediately followed by a null byte, even though thisis not matched when type is ‘text’. Conversely, whentype is ‘binary’ the pattern ‘.’ (period) might notmatch a null byte.Warning: The -a (--binary-files=text) optionmight output binary garbage, which can have nasty side effects if theoutput is a terminal and if the terminal driver interprets some of itas commands. On the other hand, when reading files whose textencodings are unknown, it can be helpful to use -a or to set‘LC_ALL='C'’ in the environment, in order to find more matcheseven if the matches are unsafe for direct display.
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 areskipped 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.
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.Skip any command-line file with a name suffix that matches the patternglob, using wildcard matching; a name suffix is either the wholename, or any suffix starting after a ‘/’ and before anon-‘/’. When searching recursively, skip any subfile whose basename 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.Skip files whose name matches any of the patternsread from file (using wildcard matching as describedunder --exclude).
Skip any command-line directory with a name suffix that matches thepattern glob. When searching recursively, skip any subdirectorywhose base name matches glob. Ignore any redundant trailingslashes in glob.
Process a binary file as if it did not contain matching data;this is equivalent to the ‘--binary-files=without-match’ option.
Search only files whose name matches glob,using wildcard matching as described under --exclude.
For each directory operand,read and process all files in that directory, recursively.Follow symbolic links on the command line, but skip symlinksthat 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.
For each directory operand, read and process all files in thatdirectory, recursively, following all symbolic links.
Previous: File and Directory Selection, Up: Command-line Options [Contents][Index]
2.1.7 Other Options
Delimit the option list. Later arguments, if any, are treated asoperands even if they begin with ‘-’. For example, ‘grep PAT ---file1 file2’ searches for the pattern PAT in the files named -file1and file2.
Use line buffering on output.This can cause a performance penalty.
On platforms that distinguish between text and binary I/O,use the latter when reading and writing files otherthan the user’s terminal, so that all input bytes are read and writtenas-is. This overrides the default behavior where
grep
follows the operating system’s advice whether to use text or binaryI/O. On MS-Windows when grep
uses text I/O it reads acarriage return–newline pair as a newline and a Control-Z asend-of-file, and it writes a newline as a carriage return–newlinepair.When using text I/O --byte-offset (-b) counts and--binary-files heuristics apply to input data after text-I/Oprocessing. Also, the --binary-files heuristics need not agreewith the --binary option; that is, they may treat the data astext even if --binary is given, or vice versa.See 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.
Treat input and output data as sequences of lines, each terminated bya 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.
Next: Exit Status, Previous: Command-line Options, Up: Invoking [Contents][Index]
2.2 Environment Variables
The behavior of
grep
is affectedby the following environment variables.The locale for category
LC_foo
is specified by examining the three environment variablesLC_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 usedfor the LC_COLLATE
category.As a special case for LC_MESSAGES
only, the environment variableLANGUAGE
can contain a colon-separated list of languages thatoverrides the three environment variables that ordinarily specifythe 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 compiledwith 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 youcontrol highlighting usingSelect Graphic Rendition (SGR)commands interpreted by the terminal or terminal emulator.(See thesectionin the documentation of your text terminalfor permitted values and their meanings as character attributes.)These substring values are integers in decimal representationand can be concatenated with semicolons.
grep
takes care of assembling the resultinto 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 abilityof a terminal to highlight text, or change its color, and so on.These capabilities are stored in an online database and accessed bythe terminfo
library.GREP_OPTIONS
This variable specifies default options to be placed in front of anyexplicit options.As this causes problems when writing portable scripts, this featurewill 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’ youcan prepend $HOME/bin to your PATH
and create anexecutable script $HOME/bin/grep containing the following: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 highlightthe 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 attributesused to highlight various parts of the output.Its value is a colon-separated list of
terminfo
capabilitiesthat 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’ capabilityand 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’ capabilityand 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 ofthe ‘sl=’ and ‘cx=’ capabilitieswhen 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’) capabilityremains 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’) capabilityremains 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 insertedbetween selected line fields (‘:’),between context line fields (‘-’),and between groups of adjacent lineswhen 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 lineusing 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 terminalsfor 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]’ areinterpreted.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, whethertext is encoded in UTF-8, ASCII, or some other encoding. In the‘C’ or ‘POSIX’ locale, all characters are encoded as asingle byte and every byte is a valid character.In more-complex encodings such as UTF-8, a sequence of multiple bytesmay be needed to represent a character, and some bytes may be encodingerrors that do not contribute to the representation of any character.POSIX does not specify the behavior of grep
when patterns orinput data contain encoding errors or null characters, so portablescripts should avoid such usage. As an extension to POSIX, GNUgrep
treats null characters like any other character.However, unless the -a (--binary-files=text) optionis used, the presence of null characters in input or of encodingerrors in output causes GNU grep
to treat the file as binaryand suppress details about matches. See File and Directory Selection.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.POSIXrequires that options thatfollow file names must be treated as file names;by default,such options are permuted to the front of the operand listand are treated as options.Also, POSIXLY_CORRECT
disables special handling of aninvalid bracket expression. See 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 expansionand 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.Next: grep Programs, Previous: Environment Variables, Up: Invoking [Contents][Index]
2.3 Exit Status
Normally the exit status is 0 if a line is selected, 1 if no lineswere selected, and 2 if an error occurred. However, if the-L or --files-without-match is used, the exit statusis 0 if a file is listed, 1 if no files were listed, and 2 if an erroroccurred. Also, if the-q or --quiet or --silent option is usedand a line is selected, the exit status is 0 even if an erroroccurred. Other
grep
implementations may exit with statusgreater than 2 on error.Previous: Exit Status, Up: Invoking [Contents][Index]
2.4 grep
Programs
grep
searches the named input filesfor lines containing a match to the given patterns.By default, grep
prints the matching lines.A file named - stands for standard input.If no input is specified, grep
searches the workingdirectory . if given a command-line option specifyingrecursion; otherwise, grep
searches standard input.There are four major variants of grep
,controlled by the following options.Interpret patterns as basic regular expressions (BREs).This is the default.
Interpret patterns as extended regular expressions (EREs).(-E is specified by POSIX.)
Interpret patterns as fixed strings, not regular expressions.(-F is specified by POSIX.)
Interpret patterns as Perl-compatible regular expressions (PCREs).PCRE support is here to stay, but consider this option experimental whencombined with the -z (--null-data) option, and note that‘grep -P’ may warn of unimplemented features.See 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 eitheregrep
or fgrep
is deprecated,but is provided to allow historical applicationsthat rely on them to run unmodified.Next: Usage, Previous: Invoking, Up: Top [Contents][Index]
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
understandsthree 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 andextended 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, andare documented in the pcresyntax(3) and pcrepattern(3) manualpages, but work only if PCRE is available in the system.• Fundamental Structure: |
• Character Classes and Bracket Expressions: |
• The Backslash Character and Special Expressions: |
• Anchoring: |
• Back-references and Subexpressions: |
• Basic vs Extended: |
Next: Character Classes and Bracket Expressions, Up: Regular Expressions [Contents][Index]
3.1 Fundamental Structure
The fundamental building blocks are the regular expressions that matcha single character.Most characters, including all letters and digits,are regular expressions that match themselves.Any meta-characterwith special meaning may be quoted by preceding it with a backslash.
The period ‘.’ matches any single character.It is unspecified whether ‘.’ matches an encoding error.
A regular expression may be followed by one of severalrepetition operators:
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.
The preceding item is matched exactly n times.
The preceding item is matched n or more times.
The preceding item is matched at most m times.This is a GNU extension.
The preceding item is matched at least n times, but not more thanm times.
The empty regular expression matches the empty string.Two regular expressions may be concatenated;the resulting regular expressionmatches any string formed by concatenating two substringsthat respectively match the concatenated expressions.
Two regular expressions may be joined by the infix operator ‘|’;the resulting regular expressionmatches any string matching either alternate expression.
Repetition takes precedence over concatenation,which in turn takes precedence over alternation.A whole expression may be enclosed in parenthesesto override these precedence rules and form a subexpression.An unmatched ‘)’ matches just itself.
Next: The Backslash Character and Special Expressions, Previous: Fundamental Structure, Up: Regular Expressions [Contents][Index]
3.2 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,and it is unspecified whether it matches an encoding error.For example, the regular expression‘[0123456789]’ matches any single digit,whereas ‘[^()]’ matches any single character that is notan opening or closing parenthesis, and might or might not match anencoding error.
Within a bracket expression, a range expression consists of twocharacters separated by a hyphen.It matches any single character thatsorts between the two characters, inclusive.In the default C locale, the sorting sequence is the native characterorder; for example, ‘[a-d]’ is equivalent to ‘[abcd]’.In other locales, the sorting sequence is not specified, and‘[a-d]’ might be equivalent to ‘[abcd]’ or to‘[aBbCcDd]’, or it might fail to match any character, or the set ofcharacters that it matches might even be erratic.To obtain the traditional interpretationof 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 withinbracket expressions, as follows.Their interpretation depends on the
LC_CTYPE
locale;for example, ‘[[:alnum:]]’ means the character class of numbers and lettersin the current locale.Alphanumeric characters:‘[:alpha:]’ and ‘[:digit:]’; in the ‘C’ locale and ASCIIcharacter encoding, this is the same as ‘[0-9A-Za-z]’.
Alphabetic characters:‘[:lower:]’ and ‘[:upper:]’; in the ‘C’ locale and ASCIIcharacter encoding, this is the same as ‘[A-Za-z]’.
Blank characters:space and tab.
Control characters.In ASCII, these characters have octal codes 000through 037, and 177 (DEL).In other character sets, these arethe equivalent characters, if any.
Digits:
0 1 2 3 4 5 6 7 8 9
.Graphical characters:‘[:alnum:]’ and ‘[:punct:]’.
Lower-case letters; in the ‘C’ locale and ASCII characterencoding, this is
a b c d e f g h i j k l m n o p q r s t u v w x y z
.Printable characters:‘[:alnum:]’, ‘[:punct:]’, and space.
Punctuation characters; in the ‘C’ locale and ASCII characterencoding, this is
! ' # $ % & ' ( ) * + , - . / : ; < = > ? @ [ ] ^ _ ` { | } ~
.Space characters: in the ‘C’ locale, this istab, newline, vertical tab, form feed, carriage return, and space.See Usage, for more discussion of matching newlines.
Upper-case letters: in the ‘C’ locale and ASCII characterencoding, this is
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
.Hexadecimal digits:
0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f
.Note that the brackets in these class names arepart of the symbolic names, and must be included in addition tothe brackets delimiting the bracket expression.
If you mistakenly omit the outer brackets, and search for say, ‘[:upper:]’,GNU
grep
prints a diagnostic and exits with status 2, onthe assumption that you did not intend to search for the nominallyequivalent regular expression: ‘[:epru]’.Set the POSIXLY_CORRECT
environment variable to disable this feature.Most meta-characters lose their special meaning inside bracket expressions.
ends the bracket expression if it’s not the first list item.So, if you want to make the ‘]’ character a list item,you must put it first.
represents the open collating symbol.
represents the close collating symbol.
represents the open equivalence class.
represents the close equivalence class.
represents the open character class symbol, and should be followed by avalid character class name.
represents the close character class symbol.
represents the range if it’s not first or last in a list or the ending pointof a range.
represents the characters not in the list.If you want to make the ‘^’character a list item, place it anywhere but first.
Next: Anchoring, Previous: Character Classes and Bracket Expressions, Up: Regular Expressions [Contents][Index]
3.3 The Backslash Character and Special Expressions
The ‘’ character,when followed by certain ordinary characters,takes a special meaning:
Match the empty string at the edge of a word.
Match the empty string provided it’s not at the edge of a word.
Match the empty string at the beginning of word.
Match the empty string at the end of word.
Match word constituent, it is a synonym for ‘[_[:alnum:]]’.
Match non-word constituent, it is a synonym for ‘[^_[:alnum:]]’.
Match whitespace, it is a synonym for ‘[[:space:]]’.
Match non-whitespace, it is a synonym for ‘[^[:space:]]’.
For example, ‘bratb’ matches the separate word ‘rat’,‘BratB’ matches ‘crate’ but not ‘furry rat’.
Next: Back-references and Subexpressions, Previous: The Backslash Character and Special Expressions, Up: Regular Expressions [Contents][Index]
3.4 Anchoring
The caret ‘^’ and the dollar sign ‘$’ are meta-characters thatrespectively match the empty string at the beginning and end of a line.They are termed anchors, since they force the match to be “anchored”to beginning or end of a line, respectively.
Next: Basic vs Extended, Previous: Anchoring, Up: Regular Expressions [Contents][Index]
3.5 Back-references and Subexpressions
The back-reference ‘n’, where n is a single digit, matchesthe substring previously matched by the nth parenthesized subexpressionof the regular expression.For example, ‘(a)1’ matches ‘aa’.When used with alternation, if the group does not participate in the match thenthe back-reference makes the whole match fail.For example, ‘a(.)|b1’will not match ‘ba’.When multiple regular expressions are given with-e or from a file (‘-f file’),back-references are local to each expression.
Previous: Back-references and Subexpressions, Up: Regular Expressions [Contents][Index]
3.6 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, soportable scripts should avoid ‘{’ in ‘grep -E’ patterns andshould use ‘[{]’ to match a literal ‘{’.GNU
grep -E
attempts to support traditional usage byassuming that ‘{’ is not special if it would be the start of aninvalid 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 scriptsshould avoid it.Next: Performance, Previous: Regular Expressions, Up: Top [Contents][Index]
4 Usage
Here is an example command that invokes GNU
grep
:This lists all lines in the files menu.h and main.c thatcontain the string ‘hello’ followed by the string ‘world’;this is because ‘.*’ matches zero or more characters within a line.See Regular Expressions.The -i option causes
grep
to ignore case, causing it to match the line ‘Hello, world!’, whichit would not otherwise match.See Invoking, for more details abouthow to invoke grep
.Here are some common questions and answers about
grep
usage.- How can I list just the names of matching files?lists the names of all C files in the current directory whose contentsmention ‘main’.
- How do I search directories recursively?searches for ‘hello’ in all filesunder the /home/gigi directory.For more control over which files are searched,use
find
,grep
, andxargs
.For example, the following command searches only C files:This differs from the command:which merely looks for ‘hello’ in all files in the currentdirectory whose names end in ‘.c’.The ‘find ...’ command line above is more similar to the command: - What if a pattern has a leading ‘-’?searches for all lines matching ‘--cut here--’.Without -e,
grep
would attempt to parse ‘--cut here--’ as a list ofoptions. - Suppose I want to search for a whole word, not a part of a word?searches only for instances of ‘hello’ that are entire words;it does not match ‘Othello’.For more control, use ‘<’ and‘>’ to match the start and end of words.For example:searches only for words ending in ‘hello’, so it matches the word‘Othello’.
- How do I output context around the matching lines?prints two lines of context around each matching line.
- How do I force
grep
to print the name of the file?Append /dev/null:gets you:Alternatively, use -H, which is a GNU extension: - Why do people use strange regular expressions on
ps
output?If the pattern had been written without the square brackets, it wouldhave matched not only theps
output line forcron
,but also theps
output line forgrep
.Note that on some platforms,ps
limits the output to the width of the screen;grep
does not have any limit on the length of a lineexcept the available memory. - Why does
grep
report “Binary file matches”?Ifgrep
listed all matching “lines” from a binary file, itwould probably generate output that is not useful, and it might evenmuck up your display.So GNUgrep
suppresses output fromfiles that appear to be binary files.To force GNUgrep
to output lines even from files that appear to be binary, use the-a or ‘--binary-files=text’ option.To eliminate the“Binary file matches” messages, use the -I or‘--binary-files=without-match’ option. - Why doesn’t ‘grep -lv’ print non-matching file names?‘grep -lv’ lists the names of all files containing one or morelines that do not match.To list the names of all files that contain nomatching lines, use the -L or --files-without-matchoption.
- I can do “OR” with ‘|’, but what about “AND”?finds all lines that contain both ‘paul’ and ‘franc,ois’.
- Why does the empty pattern match every input line?The
grep
command searches for lines that contain stringsthat match a pattern. Every line contains the empty string, so anempty pattern causesgrep
to find a match on each line. Itis not the only such pattern: ‘^’, ‘$’, ‘.*’, and manyother patterns causegrep
to match every line.To match empty lines, use the pattern ‘^$’. To match blanklines, use the pattern ‘^[[:blank:]]*$’. To match no lines atall, use the command ‘grep -f /dev/null’. - How can I search in both standard input and in files?Use the special file name ‘-’:
- How to express palindromes in a regular expression?It can be done by using back-references;for example,a palindrome of 4 characters can be written with a BRE:It matches the word “radar” or “civic.”Guglielmo Bondioni proposed a single REthat finds all palindromes up to 19 characters longusing 9 subexpressions and 9 back-references:Note this is done by using GNU ERE extensions;it might not be portable to other implementations of
grep
. - Why is this back-reference failing?This gives no output, because the first alternate ‘(a)1’ does not match,as there is no ‘aa’ in the input, so the ‘1’ in the second alternatehas nothing to refer back to, meaning it will never match anything.(The second alternate in this example can only matchif the first alternate has matched—making the second one superfluous.)
- How can I match across lines?Standard grep cannot do this, as it is fundamentally line-based.Therefore, merely using the
[:space:]
character class does notmatch newlines in the way you might expect.With the GNUgrep
option -z (--null-data), eachinput and output “line” is null-terminated; see Other Options. Thus,you can match newlines in the input, but typically if there is a matchthe entire input is output, so this usage is often combined withoutput-suppressing options like -q, e.g.:If this does not suffice, you can transform the inputbefore giving it togrep
, or turn toawk
,sed
,perl
, or many other utilities that aredesigned to operate across lines. - What do
grep
,fgrep
, andegrep
stand for?The namegrep
comes from the way line editing was done on Unix.For example,ed
uses the following syntaxto print a list of matching lines on the screen:fgrep
stands for Fixedgrep
;egrep
stands for Extendedgrep
.
Next: Reporting Bugs, Previous: Usage, Up: Top [Contents][Index]
5 Performance
Typically
grep
is an efficient way to search text. However,it can be quite slow in some cases, and it can search large fileswhere even minor performance tweaking can help significantly.Although the algorithm used by grep
is an implementationdetail that can change from release to release, understanding itsbasic strengths and weaknesses can help you improve its performance.The
grep
command operates partly via a set of automata thatare designed for efficiency, and partly via a slower matcher thattakes over when the fast matchers run into unusual features likeback-references. When feasible, the Boyer–Moore fast stringsearching algorithm is used to match a single fixed pattern, and theAho–Corasick algorithm is used to match multiple fixed patterns.Generally speaking
grep
operates more efficiently insingle-byte locales, since it can avoid the special processing neededfor multi-byte characters. If your patterns will work just as wellthat way, setting LC_ALL
to a single-byte locale can helpperformance considerably. Setting ‘LC_ALL='C'’ can beparticularly efficient, as grep
is tuned for that locale.Outside the ‘C’ locale, case-insensitive search, and search forbracket expressions like ‘[a-z]’ and ‘[[=a=]b]’, can besurprisingly inefficient due to difficulties in fast portable access toconcepts like multi-character collating elements.
A back-reference such as ‘1’ can hurt performance significantlyin some cases, since back-references cannot in general be implementedvia a finite state automaton, and instead trigger a backtrackingalgorithm that can be quite inefficient. For example, although thepattern ‘^(.*)1{14}(.*)2{13}$’ matches only lines whoselengths can be written as a sum 15x + 14y for nonnegativeintegers x and y, the pattern matcher does not performlinear Diophantine analysis and instead backtracks through allpossible matching strings, using an algorithm that is exponential inthe worst case.
![Binary Binary](/uploads/1/2/4/8/124819598/827197396.png)
On some operating systems that support files with holes—largeregions of zeros that are not physically present on secondarystorage--
grep
can skip over the holes efficiently withoutneeding to read the zeros. This optimization is not available if the-a (--binary-files=text) option is used (see File and Directory Selection), unless the -z (--null-data)option is also used (see Other Options).For more about the algorithms used by
grep
and aboutrelated string matching algorithms, see:- Aho AV. Algorithms for finding patterns in strings.In: van Leeuwen J. Handbook of Theoretical Computer Science, vol. A.New York: Elsevier; 1990. p. 255–300.This surveys classic string matching algorithms, some of which areused by
grep
. - Aho AV, Corasick MJ. Efficient string matching: an aid to bibliographic search.CACM. 1975;18(6):333–40.https://dx.doi.org/10.1145/360825.360855.This introduces the Aho–Corasick algorithm.
- Boyer RS, Moore JS. A fast string searching algorithm.CACM. 1977;20(10):762–72.https://dx.doi.org/10.1145/359842.359859.This introduces the Boyer–Moore algorithm.
- Faro S, Lecroq T. The exact online string matching problem: a reviewof the most recent results.ACM Comput Surv. 2013;45(2):13.https://dx.doi.org/10.1145/2431211.2431212.This surveys string matching algorithms that might help improve theperformance of
grep
in the future.
Next: Copying, Previous: Performance, Up: Top [Contents][Index]
6 Reporting bugs
Bug reports can be found at theGNU bug report logs for
grep
.If you find a bug not listed there, please email it [email protected] to create a new bug report.6.1 Known Bugs
Large repetition counts in the ‘{n,m}’ construct may cause
grep
to use lots of memory.In addition, certain otherobscure regular expressions require exponential time andspace, and may cause grep
to run out of memory.Back-references are very slow, and may require exponential time.
Next: Index, Previous: Reporting Bugs, Up: Top [Contents][Index]
7 Copying
GNU
grep
is licensed under the GNU GPL, which makes it freesoftware.The “free” in “free software” refers to liberty, not price. Assome GNU project advocates like to point out, think of “free speech”rather than “free beer”. In short, you have the right (freedom) torun and change
grep
and distribute it to other people, and—if youwant—charge money for doing either. The important restriction isthat you have to grant your recipients the same rights and impose thesame restrictions.This general method of licensing software is sometimes calledopen source. The GNU project prefers the term “free software”for reasons outlined athttps://www.gnu.org/philosophy/open-source-misses-the-point.html.
This manual is free documentation in the same sense. Thedocumentation license is included below. The license for the programis available with the source code, or athttps://www.gnu.org/licenses/gpl.html.
• GNU Free Documentation License: |
7.1 GNU Free Documentation License
Version 1.3, 3 November 2008
- PREAMBLEThe purpose of this License is to make a manual, textbook, or otherfunctional and useful document free in the sense of freedom: toassure everyone the effective freedom to copy and redistribute it,with or without modifying it, either commercially or noncommercially.Secondarily, this License preserves for the author and publisher a wayto get credit for their work, while not being considered responsiblefor modifications made by others.This License is a kind of “copyleft”, which means that derivativeworks of the document must themselves be free in the same sense. Itcomplements the GNU General Public License, which is a copyleftlicense designed for free software.We have designed this License in order to use it for manuals for freesoftware, because free software needs free documentation: a freeprogram should come with manuals providing the same freedoms that thesoftware does. But this License is not limited to software manuals;it can be used for any textual work, regardless of subject matter orwhether it is published as a printed book. We recommend this Licenseprincipally for works whose purpose is instruction or reference.
- APPLICABILITY AND DEFINITIONSThis License applies to any manual or other work, in any medium, thatcontains a notice placed by the copyright holder saying it can bedistributed under the terms of this License. Such a notice grants aworld-wide, royalty-free license, unlimited in duration, to use thatwork under the conditions stated herein. The “Document”, below,refers to any such manual or work. Any member of the public is alicensee, and is addressed as “you”. You accept the license if youcopy, modify or distribute the work in a way requiring permissionunder copyright law.A “Modified Version” of the Document means any work containing theDocument or a portion of it, either copied verbatim, or withmodifications and/or translated into another language.A “Secondary Section” is a named appendix or a front-matter sectionof the Document that deals exclusively with the relationship of thepublishers or authors of the Document to the Document’s overallsubject (or to related matters) and contains nothing that could falldirectly within that overall subject. (Thus, if the Document is inpart a textbook of mathematics, a Secondary Section may not explainany mathematics.) The relationship could be a matter of historicalconnection with the subject or with related matters, or of legal,commercial, philosophical, ethical or political position regardingthem.The “Invariant Sections” are certain Secondary Sections whose titlesare designated, as being those of Invariant Sections, in the noticethat says that the Document is released under this License. If asection does not fit the above definition of Secondary then it is notallowed to be designated as Invariant. The Document may contain zeroInvariant Sections. If the Document does not identify any InvariantSections then there are none.The “Cover Texts” are certain short passages of text that are listed,as Front-Cover Texts or Back-Cover Texts, in the notice that says thatthe Document is released under this License. A Front-Cover Text maybe at most 5 words, and a Back-Cover Text may be at most 25 words.A “Transparent” copy of the Document means a machine-readable copy,represented in a format whose specification is available to thegeneral public, that is suitable for revising the documentstraightforwardly with generic text editors or (for images composed ofpixels) generic paint programs or (for drawings) some widely availabledrawing editor, and that is suitable for input to text formatters orfor automatic translation to a variety of formats suitable for inputto text formatters. A copy made in an otherwise Transparent fileformat whose markup, or absence of markup, has been arranged to thwartor discourage subsequent modification by readers is not Transparent.An image format is not Transparent if used for any substantial amountof text. A copy that is not “Transparent” is called “Opaque”.Examples of suitable formats for Transparent copies include plainASCII without markup, Texinfo input format, LaTeX inputformat, SGML or XML using a publicly availableDTD, and standard-conforming simple HTML,PostScript or PDF designed for human modification. Examplesof transparent image formats include PNG, XCF andJPG. Opaque formats include proprietary formats that can beread and edited only by proprietary word processors, SGML orXML for which the DTD and/or processing tools arenot generally available, and the machine-generated HTML,PostScript or PDF produced by some word processors foroutput purposes only.The “Title Page” means, for a printed book, the title page itself,plus such following pages as are needed to hold, legibly, the materialthis License requires to appear in the title page. For works informats which do not have any title page as such, “Title Page” meansthe text near the most prominent appearance of the work’s title,preceding the beginning of the body of the text.The “publisher” means any person or entity that distributes copiesof the Document to the public.A section “Entitled XYZ” means a named subunit of the Document whosetitle either is precisely XYZ or contains XYZ in parentheses followingtext that translates XYZ in another language. (Here XYZ stands for aspecific section name mentioned below, such as “Acknowledgements”,“Dedications”, “Endorsements”, or “History”.) To “Preserve the Title”of such a section when you modify the Document means that it remains asection “Entitled XYZ” according to this definition.The Document may include Warranty Disclaimers next to the notice whichstates that this License applies to the Document. These WarrantyDisclaimers are considered to be included by reference in thisLicense, but only as regards disclaiming warranties: any otherimplication that these Warranty Disclaimers may have is void and hasno effect on the meaning of this License.
- VERBATIM COPYINGYou may copy and distribute the Document in any medium, eithercommercially or noncommercially, provided that this License, thecopyright notices, and the license notice saying this License appliesto the Document are reproduced in all copies, and that you add no otherconditions whatsoever to those of this License. You may not usetechnical measures to obstruct or control the reading or furthercopying of the copies you make or distribute. However, you may acceptcompensation in exchange for copies. If you distribute a large enoughnumber of copies you must also follow the conditions in section 3.You may also lend copies, under the same conditions stated above, andyou may publicly display copies.
- COPYING IN QUANTITYIf you publish printed copies (or copies in media that commonly haveprinted covers) of the Document, numbering more than 100, and theDocument’s license notice requires Cover Texts, you must enclose thecopies in covers that carry, clearly and legibly, all these CoverTexts: Front-Cover Texts on the front cover, and Back-Cover Texts onthe back cover. Both covers must also clearly and legibly identifyyou as the publisher of these copies. The front cover must presentthe full title with all words of the title equally prominent andvisible. You may add other material on the covers in addition.Copying with changes limited to the covers, as long as they preservethe title of the Document and satisfy these conditions, can be treatedas verbatim copying in other respects.If the required texts for either cover are too voluminous to fitlegibly, you should put the first ones listed (as many as fitreasonably) on the actual cover, and continue the rest onto adjacentpages.If you publish or distribute Opaque copies of the Document numberingmore than 100, you must either include a machine-readable Transparentcopy along with each Opaque copy, or state in or with each Opaque copya computer-network location from which the general network-usingpublic has access to download using public-standard network protocolsa complete Transparent copy of the Document, free of added material.If you use the latter option, you must take reasonably prudent steps,when you begin distribution of Opaque copies in quantity, to ensurethat this Transparent copy will remain thus accessible at the statedlocation until at least one year after the last time you distribute anOpaque copy (directly or through your agents or retailers) of thatedition to the public.It is requested, but not required, that you contact the authors of theDocument well before redistributing any large number of copies, to givethem a chance to provide you with an updated version of the Document.
- MODIFICATIONSYou may copy and distribute a Modified Version of the Document underthe conditions of sections 2 and 3 above, provided that you releasethe Modified Version under precisely this License, with the ModifiedVersion filling the role of the Document, thus licensing distributionand modification of the Modified Version to whoever possesses a copyof it. In addition, you must do these things in the Modified Version:
- Use in the Title Page (and on the covers, if any) a title distinctfrom that of the Document, and from those of previous versions(which should, if there were any, be listed in the History sectionof the Document). You may use the same title as a previous versionif the original publisher of that version gives permission.
- List on the Title Page, as authors, one or more persons or entitiesresponsible for authorship of the modifications in the ModifiedVersion, together with at least five of the principal authors of theDocument (all of its principal authors, if it has fewer than five),unless they release you from this requirement.
- State on the Title page the name of the publisher of theModified Version, as the publisher.
- Preserve all the copyright notices of the Document.
- Add an appropriate copyright notice for your modificationsadjacent to the other copyright notices.
- Include, immediately after the copyright notices, a license noticegiving the public permission to use the Modified Version under theterms of this License, in the form shown in the Addendum below.
- Preserve in that license notice the full lists of Invariant Sectionsand required Cover Texts given in the Document’s license notice.
- Include an unaltered copy of this License.
- Preserve the section Entitled “History”, Preserve its Title, and addto it an item stating at least the title, year, new authors, andpublisher of the Modified Version as given on the Title Page. Ifthere is no section Entitled “History” in the Document, create onestating the title, year, authors, and publisher of the Document asgiven on its Title Page, then add an item describing the ModifiedVersion as stated in the previous sentence.
- Preserve the network location, if any, given in the Document forpublic access to a Transparent copy of the Document, and likewisethe network locations given in the Document for previous versionsit was based on. These may be placed in the “History” section.You may omit a network location for a work that was published atleast four years before the Document itself, or if the originalpublisher of the version it refers to gives permission.
- For any section Entitled “Acknowledgements” or “Dedications”, Preservethe Title of the section, and preserve in the section all thesubstance and tone of each of the contributor acknowledgements and/ordedications given therein.
- Preserve all the Invariant Sections of the Document,unaltered in their text and in their titles. Section numbersor the equivalent are not considered part of the section titles.
- Delete any section Entitled “Endorsements”. Such a sectionmay not be included in the Modified Version.
- Do not retitle any existing section to be Entitled “Endorsements” orto conflict in title with any Invariant Section.
- Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections orappendices that qualify as Secondary Sections and contain no materialcopied from the Document, you may at your option designate some or allof these sections as invariant. To do this, add their titles to thelist of Invariant Sections in the Modified Version’s license notice.These titles must be distinct from any other section titles.You may add a section Entitled “Endorsements”, provided it containsnothing but endorsements of your Modified Version by variousparties—for example, statements of peer review or that the text hasbeen approved by an organization as the authoritative definition of astandard.You may add a passage of up to five words as a Front-Cover Text, and apassage of up to 25 words as a Back-Cover Text, to the end of the listof Cover Texts in the Modified Version. Only one passage ofFront-Cover Text and one of Back-Cover Text may be added by (orthrough arrangements made by) any one entity. If the Document alreadyincludes a cover text for the same cover, previously added by you orby arrangement made by the same entity you are acting on behalf of,you may not add another; but you may replace the old one, on explicitpermission from the previous publisher that added the old one.The author(s) and publisher(s) of the Document do not by this Licensegive permission to use their names for publicity for or to assert orimply endorsement of any Modified Version. - COMBINING DOCUMENTSYou may combine the Document with other documents released under thisLicense, under the terms defined in section 4 above for modifiedversions, provided that you include in the combination all of theInvariant Sections of all of the original documents, unmodified, andlist them all as Invariant Sections of your combined work in itslicense notice, and that you preserve all their Warranty Disclaimers.The combined work need only contain one copy of this License, andmultiple identical Invariant Sections may be replaced with a singlecopy. If there are multiple Invariant Sections with the same name butdifferent contents, make the title of each such section unique byadding at the end of it, in parentheses, the name of the originalauthor or publisher of that section if known, or else a unique number.Make the same adjustment to the section titles in the list ofInvariant Sections in the license notice of the combined work.In the combination, you must combine any sections Entitled “History”in the various original documents, forming one section Entitled“History”; likewise combine any sections Entitled “Acknowledgements”,and any sections Entitled “Dedications”. You must delete allsections Entitled “Endorsements.”
- COLLECTIONS OF DOCUMENTSYou may make a collection consisting of the Document and other documentsreleased under this License, and replace the individual copies of thisLicense in the various documents with a single copy that is included inthe collection, provided that you follow the rules of this License forverbatim copying of each of the documents in all other respects.You may extract a single document from such a collection, and distributeit individually under this License, provided you insert a copy of thisLicense into the extracted document, and follow this License in allother respects regarding verbatim copying of that document.
- AGGREGATION WITH INDEPENDENT WORKSA compilation of the Document or its derivatives with other separateand independent documents or works, in or on a volume of a storage ordistribution medium, is called an “aggregate” if the copyrightresulting from the compilation is not used to limit the legal rightsof the compilation’s users beyond what the individual works permit.When the Document is included in an aggregate, this License does notapply to the other works in the aggregate which are not themselvesderivative works of the Document.If the Cover Text requirement of section 3 is applicable to thesecopies of the Document, then if the Document is less than one half ofthe entire aggregate, the Document’s Cover Texts may be placed oncovers that bracket the Document within the aggregate, or theelectronic equivalent of covers if the Document is in electronic form.Otherwise they must appear on printed covers that bracket the wholeaggregate.
- TRANSLATIONTranslation is considered a kind of modification, so you maydistribute translations of the Document under the terms of section 4.Replacing Invariant Sections with translations requires specialpermission from their copyright holders, but you may includetranslations of some or all Invariant Sections in addition to theoriginal versions of these Invariant Sections. You may include atranslation of this License, and all the license notices in theDocument, and any Warranty Disclaimers, provided that you also includethe original English version of this License and the original versionsof those notices and disclaimers. In case of a disagreement betweenthe translation and the original version of this License or a noticeor disclaimer, the original version will prevail.If a section in the Document is Entitled “Acknowledgements”,“Dedications”, or “History”, the requirement (section 4) to Preserveits Title (section 1) will typically require changing the actualtitle.
- TERMINATIONYou may not copy, modify, sublicense, or distribute the Documentexcept as expressly provided under this License. Any attemptotherwise to copy, modify, sublicense, or distribute it is void, andwill automatically terminate your rights under this License.However, if you cease all violation of this License, then your licensefrom a particular copyright holder is reinstated (a) provisionally,unless and until the copyright holder explicitly and finallyterminates your license, and (b) permanently, if the copyright holderfails to notify you of the violation by some reasonable means prior to60 days after the cessation.Moreover, your license from a particular copyright holder isreinstated permanently if the copyright holder notifies you of theviolation by some reasonable means, this is the first time you havereceived notice of violation of this License (for any work) from thatcopyright holder, and you cure the violation prior to 30 days afteryour receipt of the notice.Termination of your rights under this section does not terminate thelicenses of parties who have received copies or rights from you underthis License. If your rights have been terminated and not permanentlyreinstated, receipt of a copy of some or all of the same material doesnot give you any rights to use it.
- FUTURE REVISIONS OF THIS LICENSEThe Free Software Foundation may publish new, revised versionsof the GNU Free Documentation License from time to time. Such newversions will be similar in spirit to the present version, but maydiffer in detail to address new problems or concerns. Seehttps://www.gnu.org/copyleft/.Each version of the License is given a distinguishing version number.If the Document specifies that a particular numbered version of thisLicense “or any later version” applies to it, you have the option offollowing the terms and conditions either of that specified version orof any later version that has been published (not as a draft) by theFree Software Foundation. If the Document does not specify a versionnumber of this License, you may choose any version ever published (notas a draft) by the Free Software Foundation. If the Documentspecifies that a proxy can decide which future versions of thisLicense can be used, that proxy’s public statement of acceptance of aversion permanently authorizes you to choose that version for theDocument.
- RELICENSING“Massive Multiauthor Collaboration Site” (or “MMC Site”) means anyWorld Wide Web server that publishes copyrightable works and alsoprovides prominent facilities for anybody to edit those works. Apublic wiki that anybody can edit is an example of such a server. A“Massive Multiauthor Collaboration” (or “MMC”) contained in thesite means any set of copyrightable works thus published on the MMCsite.“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0license published by Creative Commons Corporation, a not-for-profitcorporation with a principal place of business in San Francisco,California, as well as future copyleft versions of that licensepublished by that same organization.“Incorporate” means to publish or republish a Document, in whole orin part, as part of another Document.An MMC is “eligible for relicensing” if it is licensed under thisLicense, and if all works that were first published under this Licensesomewhere other than this MMC, and subsequently incorporated in wholeor in part into the MMC, (1) had no cover texts or invariant sections,and (2) were thus incorporated prior to November 1, 2008.The operator of an MMC Site may republish an MMC contained in the siteunder CC-BY-SA on the same site at any time before August 1, 2009,provided the MMC is eligible for relicensing.
ADDENDUM: How to use this License for your documents
To use this License in a document you have written, include a copy ofthe License in the document and put the following copyright andlicense notices just after the title page:
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,replace the “with…Texts.” line with this:
If you have Invariant Sections without Cover Texts, or some othercombination of the three, merge those two alternatives to suit thesituation.
If your document contains nontrivial examples of program code, werecommend releasing these examples in parallel under your choice offree software license, such as the GNU General Public License,to permit their use in free software.
Previous: Copying, Up: Top [Contents][Index]
Index
Jump to: | *+-.?_{ ABCDEFGHILMNOPQRSTUVWXZ |
---|
Index Entry | Section |
---|---|
* | |
* : | Fundamental Structure |
+ | |
+ : | Fundamental Structure |
- | |
-- : | Other Options |
--after-context : | Context Line Control |
--basic-regexp : | grep Programs |
--before-context : | Context Line Control |
--binary : | Other Options |
--binary-files : | File and Directory Selection |
--byte-offset : | Output Line Prefix Control |
--color : | General Output Control |
--colour : | General Output Control |
--context : | Context Line Control |
--count : | General Output Control |
--dereference-recursive : | File and Directory Selection |
--devices : | File and Directory Selection |
--directories : | File and Directory Selection |
--exclude : | File and Directory Selection |
--exclude-dir : | File and Directory Selection |
--exclude-from : | File and Directory Selection |
--extended-regexp : | grep Programs |
--file : | Matching Control |
--files-with-matches : | General Output Control |
--files-without-match : | General Output Control |
--fixed-strings : | grep Programs |
--group-separator : | Context Line Control |
--group-separator : | Context Line Control |
--help : | Generic Program Information |
--ignore-case : | Matching Control |
--include : | File and Directory Selection |
--initial-tab : | Output Line Prefix Control |
--invert-match : | Matching Control |
--label : | Output Line Prefix Control |
--line-buffered : | Other Options |
--line-number : | Output Line Prefix Control |
--line-regexp : | Matching Control |
--max-count : | General Output Control |
--no-filename : | Output Line Prefix Control |
--no-messages : | General Output Control |
--null : | Output Line Prefix Control |
--null-data : | Other Options |
--only-matching : | General Output Control |
--perl-regexp : | grep Programs |
--quiet : | General Output Control |
--recursive : | File and Directory Selection |
--regexp=patterns : | Matching Control |
--silent : | General Output Control |
--text : | File and Directory Selection |
--version : | Generic Program Information |
--with-filename : | Output Line Prefix Control |
--word-regexp : | Matching Control |
-A : | Context Line Control |
-a : | File and Directory Selection |
-b : | Output Line Prefix Control |
-B : | Context Line Control |
-c : | General Output Control |
-C : | Context Line Control |
-D : | File and Directory Selection |
-d : | File and Directory Selection |
-e : | Matching Control |
-E : | grep Programs |
-f : | Matching Control |
-F : | grep Programs |
-G : | grep Programs |
-H : | Output Line Prefix Control |
-h : | Output Line Prefix Control |
-i : | Matching Control |
-L : | General Output Control |
-l : | General Output Control |
-m : | General Output Control |
-n : | Output Line Prefix Control |
-num : | Context Line Control |
-o : | General Output Control |
-P : | grep Programs |
-q : | General Output Control |
-r : | File and Directory Selection |
-R : | File and Directory Selection |
-s : | General Output Control |
-T : | Output Line Prefix Control |
-U : | Other Options |
-V : | Generic Program Information |
-v : | Matching Control |
-w : | Matching Control |
-x : | Matching Control |
-y : | Matching Control |
-Z : | Output Line Prefix Control |
-z : | Other Options |
. | |
. : | Fundamental Structure |
? | |
? : | Fundamental Structure |
_ | |
_N_GNU_nonoption_argv_flags_ environment variable : | Environment Variables |
{ | |
{,m} : | Fundamental Structure |
{n,m} : | Fundamental Structure |
{n,} : | Fundamental Structure |
{n} : | Fundamental Structure |
A | |
after context: | Context Line Control |
alnum character class : | Character Classes and Bracket Expressions |
alpha character class : | Character Classes and Bracket Expressions |
alphabetic characters: | Character Classes and Bracket Expressions |
alphanumeric characters: | Character Classes and Bracket Expressions |
anchoring: | Anchoring |
asterisk: | Fundamental Structure |
B | |
back-reference: | Back-references and Subexpressions |
back-references: | Performance |
backslash: | The Backslash Character and Special Expressions |
basic regular expressions: | Basic vs Extended |
before context: | Context Line Control |
binary files: | File and Directory Selection |
binary files: | File and Directory Selection |
binary I/O: | Other Options |
blank character class : | Character Classes and Bracket Expressions |
blank characters: | Character Classes and Bracket Expressions |
bn GREP_COLORS capability : | Environment Variables |
braces, first argument omitted: | Fundamental Structure |
braces, one argument: | Fundamental Structure |
braces, second argument omitted: | Fundamental Structure |
braces, two arguments: | Fundamental Structure |
bracket expression: | Character Classes and Bracket Expressions |
Bugs, known: | Reporting Bugs |
bugs, reporting: | Reporting Bugs |
byte offset: | Output Line Prefix Control |
C | |
case insensitive search: | Matching Control |
case insensitive search: | Performance |
changing name of standard input: | Output Line Prefix Control |
character class: | Character Classes and Bracket Expressions |
character classes: | Character Classes and Bracket Expressions |
character type: | Environment Variables |
classes of characters: | Character Classes and Bracket Expressions |
cntrl character class : | Character Classes and Bracket Expressions |
context lines: | General Output Control |
context lines: | Context Line Control |
context lines: | Context Line Control |
context lines, after match: | Context Line Control |
context lines, before match: | Context Line Control |
control characters: | Character Classes and Bracket Expressions |
copying: | Copying |
counting lines: | General Output Control |
cx GREP_COLORS capability : | Environment Variables |
D | |
default options environment variable: | Environment Variables |
device search: | File and Directory Selection |
digit character class : | Character Classes and Bracket Expressions |
digit characters: | Character Classes and Bracket Expressions |
directory search: | File and Directory Selection |
dot: | Fundamental Structure |
E | |
encoding error: | Environment Variables |
environment variables: | Environment Variables |
exclude directories: | File and Directory Selection |
exclude files: | File and Directory Selection |
exclude files: | File and Directory Selection |
exit status: | Exit Status |
F | |
FAQ about grep usage: | Usage |
files which don’t match: | General Output Control |
fn GREP_COLORS capability : | Environment Variables |
fn GREP_COLORS capability : | Environment Variables |
G | |
graph character class : | Character Classes and Bracket Expressions |
graphic characters: | Character Classes and Bracket Expressions |
grep programs: | grep Programs |
GREP_COLOR environment variable : | Environment Variables |
GREP_COLORS environment variable : | Environment Variables |
GREP_OPTIONS environment variable : | Environment Variables |
group separator: | Context Line Control |
group separator: | Context Line Control |
H | |
hexadecimal digits: | Character Classes and Bracket Expressions |
highlight markers: | Environment Variables |
highlight markers: | Environment Variables |
highlight, color, colour: | General Output Control |
holes in files: | Performance |
I | |
include files: | File and Directory Selection |
interval specifications: | Basic vs Extended |
invert matching: | Matching Control |
L | |
LANG environment variable : | Environment Variables |
LANG environment variable : | Environment Variables |
LANG environment variable : | Environment Variables |
LANG environment variable : | Environment Variables |
LANGUAGE environment variable : | Environment Variables |
LANGUAGE environment variable : | Environment Variables |
language of messages: | Environment Variables |
LC_ALL environment variable : | Environment Variables |
LC_ALL environment variable : | Environment Variables |
LC_ALL environment variable : | Environment Variables |
LC_ALL environment variable : | Environment Variables |
LC_COLLATE environment variable : | Environment Variables |
LC_CTYPE environment variable : | Environment Variables |
LC_MESSAGES environment variable : | Environment Variables |
LC_MESSAGES environment variable : | Environment Variables |
line buffering: | Other Options |
line numbering: | Output Line Prefix Control |
ln GREP_COLORS capability : | Environment Variables |
locales: | Performance |
lower character class : | Character Classes and Bracket Expressions |
lower-case letters: | Character Classes and Bracket Expressions |
M | |
match expression at most m times: | Fundamental Structure |
match expression at most once: | Fundamental Structure |
match expression from n to m times: | Fundamental Structure |
match expression n or more times: | Fundamental Structure |
match expression n times: | Fundamental Structure |
match expression one or more times: | Fundamental Structure |
match expression zero or more times: | Fundamental Structure |
match the whole line: | Matching Control |
matching basic regular expressions: | grep Programs |
matching extended regular expressions: | grep Programs |
matching fixed strings: | grep Programs |
matching Perl-compatible regular expressions: | grep Programs |
matching whole words: | Matching Control |
max-count: | General Output Control |
mc GREP_COLORS capability : | Environment Variables |
message language: | Environment Variables |
ms GREP_COLORS capability : | Environment Variables |
MS-Windows binary I/O: | Other Options |
mt GREP_COLORS capability : | Environment Variables |
N | |
names of matching files: | General Output Control |
national language support: | Environment Variables |
national language support: | Environment Variables |
ne GREP_COLORS capability : | Environment Variables |
NLS: | Environment Variables |
no filename prefix: | Output Line Prefix Control |
null character: | Environment Variables |
numeric characters: | Character Classes and Bracket Expressions |
O | |
only matching: | General Output Control |
option delimiter: | Other Options |
P | |
palindromes: | Usage |
patterns from file: | Matching Control |
patterns option: | Matching Control |
performance: | Performance |
period: | Fundamental Structure |
plus sign: | Fundamental Structure |
POSIXLY_CORRECT environment variable : | Environment Variables |
print character class : | Character Classes and Bracket Expressions |
print non-matching lines: | Matching Control |
printable characters: | Character Classes and Bracket Expressions |
punct character class : | Character Classes and Bracket Expressions |
punctuation characters: | Character Classes and Bracket Expressions |
Q | |
question mark: | Fundamental Structure |
quiet, silent: | General Output Control |
R | |
range expression: | Character Classes and Bracket Expressions |
recursive search: | File and Directory Selection |
recursive search: | File and Directory Selection |
regular expressions: | Regular Expressions |
return status: | Exit Status |
rv GREP_COLORS capability : | Environment Variables |
S | |
searching directory trees: | File and Directory Selection |
searching directory trees: | File and Directory Selection |
searching directory trees: | File and Directory Selection |
searching directory trees: | File and Directory Selection |
searching directory trees: | File and Directory Selection |
searching for patterns: | Introduction |
sl GREP_COLORS capability : | Environment Variables |
space character class : | Character Classes and Bracket Expressions |
space characters: | Character Classes and Bracket Expressions |
subexpression: | Back-references and Subexpressions |
suppress binary data: | File and Directory Selection |
suppress error messages: | General Output Control |
symbolic links: | File and Directory Selection |
symbolic links: | File and Directory Selection |
symbolic links: | File and Directory Selection |
T | |
tab-aligned content lines: | Output Line Prefix Control |
translation of message language: | Environment Variables |
U | |
upper character class : | Character Classes and Bracket Expressions |
upper-case letters: | Character Classes and Bracket Expressions |
usage summary, printing: | Generic Program Information |
usage, examples: | Usage |
using grep , Q&A: | Usage |
V | |
variants of grep : | grep Programs |
version, printing: | Generic Program Information |
W | |
whitespace characters: | Character Classes and Bracket Expressions |
with filename prefix: | Output Line Prefix Control |
X | |
xdigit character class : | Character Classes and Bracket Expressions |
xdigit class: | Character Classes and Bracket Expressions |
Z | |
zero-terminated file names: | Output Line Prefix Control |
zero-terminated lines: | Other Options |
Jump to: | *+-.?_{ ABCDEFGHILMNOPQRSTUVWXZ |
---|
Footnotes
(1)
Of course, 7th EditionUnix predated POSIX by several years!