Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
GREP(1)			    General Commands Manual		       GREP(1)

       grep, egrep, fgrep - print lines	matching a pattern

       grep  [-[AB]  num]  [-HRPS]  [-CEFGLVabchilnqsvwx]  [-e expr] [-f file]

       Grep searches the named input files (or standard	input if no files  are
       named, or the file name - is given) for lines containing	a match	to the
       given pattern.  By default, grep	prints the matching lines.

       There are three major variants of grep, controlled by the following op-
       -G     Interpret	 pattern  as  a	 basic regular expression (see below).
	      This is the default.
       -E     Interpret	pattern	as an extended regular expression (see below).
       -F     Interpret	pattern	as a list of fixed strings, separated by  new-
	      lines, any of which is to	be matched.
       In addition, two	variant	programs egrep and fgrep are available.	 Egrep
       is similar (but not identical) to grep -E, and is compatible  with  the
       historical Unix egrep.  Fgrep is	the same as grep -F.

       All variants of grep understand the following options:
       -num   Matches  will  be	printed	with num lines of leading and trailing
	      context.	However, grep will never print	any  given  line  more
	      than once.
       -A num Print num	lines of trailing context after	matching lines.
       -B num Print num	lines of leading context before	matching lines.
       -C     Equivalent to -2.
       -V     Print  the  version number of grep to standard error.  This ver-
	      sion number should be included in	all bug	reports	(see below).
       -a     Don't search in binary files.
       -b     Print the	byte offset within the input file before each line  of
       -c     Suppress	normal output; instead print a count of	matching lines
	      for each input file.  With the -v	option (see below), count non-
	      matching lines.
       -e pattern
	      Use pattern as the pattern; useful to protect patterns beginning
	      with -.
       -f file
	      Obtain the pattern from file.
       -h     Suppress the prefixing of	 filenames  on	output	when  multiple
	      files are	searched.
       -i     Ignore  case  distinctions  in  both  the	 pattern and the input
       -L     Suppress normal output; instead print the	 name  of  each	 input
	      file from	which no output	would normally have been printed.
       -l     Suppress	normal	output;	 instead  print	the name of each input
	      file from	which output would normally have been printed.
       -n     Prefix each line of output with the line number within its input
       -q     Quiet; suppress normal output.
       -s     Suppress error messages about nonexistent	or unreadable files.
       -v     Invert the sense of matching, to select non-matching lines.
       -w     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 con-
	      stituent 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.
       -x     Select only those	matches	that exactly match the whole line.

       Following options only available	if compiled with FTS library:
       -H     If the -R	option is specified, symbolic  links  on  the  command
	      line are followed.  (Symbolic links encountered in the tree tra-
	      versal are not followed.)

       -L     If the -R	option is specified, all symbolic links	are followed.

       -P     If the -R	option is specified, no	symbolic links are followed.

       -R     Search in	the file hierarchies rooted in the  files  instead  of
	      just the files themselves.


       A  regular  expression  is  a  pattern that describes a set of strings.
       Regular expressions are constructed analogously to  arithmetic  expres-
       sions, by using various operators to combine smaller expressions.

       Grep  understands  two different	versions of regular expression syntax:
       ``basic'' and ``extended.''  In GNU grep, there	is  no	difference  in
       available functionality using either syntax.  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.

       The fundamental building	blocks are the regular expressions that	 match
       a single	character.  Most characters, including all letters and digits,
       are regular expressions that match themselves.  Any metacharacter  with
       special meaning may be quoted by	preceding it with a backslash.

       A  list	of characters enclosed by [ and	] 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.  For example, the regular ex-
       pression	[0123456789] matches any single	digit.	A range	of ASCII char-
       acters  may be specified	by giving the first and	last characters, sepa-
       rated by	a hyphen.  Finally, certain named classes  of  characters  are
       predefined.   Their names are self explanatory, and they	are [:alnum:],
       [:alpha:],  [:cntrl:],  [:digit:],  [:graph:],  [:lower:],   [:print:],
       [:punct:],  [:space:],  [:upper:], and [:xdigit:].  For example,	[[:al-
       num:]] means [0-9A-Za-z], except	the latter form	is dependent upon  the
       ASCII  character	 encoding, whereas the former is portable.  (Note that
       the brackets in these class names are part of the symbolic  names,  and
       must  be	 included  in  addition	to the brackets	delimiting the bracket
       list.)  Most metacharacters lose	their special  meaning	inside	lists.
       To  include  a literal ]	place it first in the list.  Similarly,	to in-
       clude a literal ^ place it anywhere but first.  Finally,	to  include  a
       literal - place it last.

       The period .  matches any single	character.  The	symbol \w is a synonym
       for [[:alnum:]] and \W is a synonym for [^[:alnum]].

       The caret ^ and the dollar sign $ are metacharacters that  respectively
       match the empty string at the beginning and end of a line.  The symbols
       \< and \> respectively match the	empty string at	the beginning and  end
       of  a  word.   The  symbol \b matches the empty string at the edge of a
       word, and \B matches the	empty string provided it's not at the edge  of
       a word.

       A regular expression matching a single character	may be followed	by one
       of several repetition operators:
       ?      The preceding item is optional and matched at most once.
       *      The preceding item will be matched zero or more times.
       +      The preceding item will be matched one or	more times.
       {n}    The preceding item is matched exactly n times.
       {n,}   The preceding item is matched n or more times.
       {,m}   The preceding item is optional and is matched at most m times.
       {n,m}  The preceding item is matched at least n	times,	but  not  more
	      than m times.

       Two  regular expressions	may be concatenated; the resulting regular ex-
       pression	matches	any string formed by concatenating two substrings that
       respectively match the concatenated subexpressions.

       Two  regular expressions	may be joined by the infix operator |; the re-
       sulting regular expression matches any string  matching	either	subex-

       Repetition  takes  precedence  over  concatenation, which in turn takes
       precedence over alternation.  A whole subexpression may be enclosed  in
       parentheses to override these precedence	rules.

       The  backreference \n, where n is a single digit, matches the substring
       previously matched by the nth parenthesized subexpression of the	 regu-
       lar expression.

       In  basic  regular  expressions the metacharacters ?, +,	{, |, (, and )
       lose their special meaning; instead use the  backslashed	 versions  \?,
       \+, \{, \|, \(, and \).

       In egrep	the metacharacter { loses its special meaning; instead use \{.

       Normally,  exit	status is 0 if matches were found, and 1 if no matches
       were found.  (The -v option inverts the	sense  of  the	exit  status.)
       Exit status is 2	if there were syntax errors in the pattern, inaccessi-
       ble input files,	or other system	errors.

       Email bug reports to  Be sure to include
       the word	``grep'' somewhere in the ``Subject:'' field.

       Large  repetition  counts  in the {m,n} construct may cause grep	to use
       lots of memory.	In addition, certain other obscure regular expressions
       require	exponential  time  and space, and may cause grep to run	out of

       Backreferences are very slow, and may require exponential time.

GNU Project		       1992 September 10		       GREP(1)


Want to link to this manual page? Use this URL:

home | help