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

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
GREP(1)				 User Commands			       GREP(1)

NAME
       grep, egrep, fgrep - print lines	matching a pattern

SYNOPSIS
       grep [OPTIONS] PATTERN [FILE...]
       grep [OPTIONS] [-e PATTERN | -f FILE] [FILE...]

DESCRIPTION
       grep  searches the named	input FILEs (or	standard input if no files are
       named, or if a single hyphen-minus (-) is given as file name) for lines
       containing  a  match to the given PATTERN.  By default, grep prints the
       matching	lines.

       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 either egrep or fgrep is deprecated, but is  provided  to
       allow historical	applications that rely on them to run unmodified.

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

       -V, --version
	      Print the	version	number of grep to the standard output  stream.
	      This  version  number should be included in all bug reports (see
	      below).

   Matcher Selection
       -E, --extended-regexp
	      Interpret	PATTERN	as an extended regular	expression  (ERE,  see
	      below).  (-E is specified	by POSIX.)

       -F, --fixed-strings
	      Interpret	 PATTERN  as  a	 list  of  fixed strings, separated by
	      newlines,	any of which is	to be matched.	(-F  is	 specified  by
	      POSIX.)

       -G, --basic-regexp
	      Interpret	 PATTERN  as  a	 basic	regular	 expression  (BRE, see
	      below).  This is the default.

       -P, --perl-regexp
	      Interpret	PATTERN	as a Perl regular expression.  This is	highly
	      experimental and grep -P may warn	of unimplemented features.

   Matching Control
       -e PATTERN, --regexp=PATTERN
	      Use  PATTERN  as	the  pattern.	This  can  be  used to specify
	      multiple search patterns,	or to protect a	pattern	beginning with
	      a	hyphen (-).  (-e is specified by POSIX.)

       -f FILE,	--file=FILE
	      Obtain  patterns	from  FILE,  one  per  line.   The  empty file
	      contains zero patterns, and therefore matches nothing.   (-f  is
	      specified	by POSIX.)

       -i, --ignore-case
	      Ignore  case  distinctions  in  both  the	 PATTERN and the input
	      files.  (-i is specified by POSIX.)

       -v, --invert-match
	      Invert the sense of matching, to select non-matching lines.  (-v
	      is specified by POSIX.)

       -w, --word-regexp
	      Select  only  those  lines  containing  matches  that form whole
	      words.  The test is that the matching substring must  either  be
	      at  the  beginning  of  the  line,  or  preceded	by  a non-word
	      constituent character.  Similarly, it must be either at the  end
	      of  the  line  or	 followed by a non-word	constituent character.
	      Word-constituent	characters  are	 letters,  digits,   and   the
	      underscore.

       -x, --line-regexp
	      Select  only  those  matches  that exactly match the whole line.
	      (-x is specified by POSIX.)

       -y     Obsolete synonym for -i.

   General Output Control
       -c, --count
	      Suppress normal output; instead print a count of matching	 lines
	      for  each	 input	file.  With the	-v, --invert-match option (see
	      below), count non-matching lines.	 (-c is	specified by POSIX.)

       --color[=WHEN], --colour[=WHEN]
	      Surround	the  matched  (non-empty)  strings,  matching	lines,
	      context  lines,  file  names,  line  numbers,  byte offsets, and
	      separators (for fields and groups	of context lines) with	escape
	      sequences	 to display them in color on the terminal.  The	colors
	      are  defined  by	the  environment  variable  GREP_COLORS.   The
	      deprecated  environment  variable	GREP_COLOR is still supported,
	      but its setting does not have priority.  WHEN is never,  always,
	      or auto.

       -L, --files-without-match
	      Suppress	normal	output;	 instead  print	the name of each input
	      file from	which no output	would normally have been printed.  The
	      scanning will stop on the	first match.

       -l, --files-with-matches
	      Suppress	normal	output;	 instead  print	the name of each input
	      file from	which output would normally have  been	printed.   The
	      scanning	will  stop  on	the  first match.  (-l is specified by
	      POSIX.)

       -m NUM, --max-count=NUM
	      Stop reading a file after	NUM matching lines.  If	the  input  is
	      standard	input  from a regular file, and	NUM matching lines are
	      output, grep ensures that	the standard input  is	positioned  to
	      just  after the last matching line before	exiting, regardless of
	      the presence of trailing context lines.  This enables a  calling
	      process  to resume a search.  When grep stops after NUM matching
	      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.

       -o, --only-matching
	      Print  only  the	matched	 (non-empty) parts of a	matching line,
	      with each	such part on a separate	output line.

       -q, --quiet, --silent
	      Quiet;  do  not  write  anything	to  standard   output.	  Exit
	      immediately  with	 zero status if	any match is found, even if an
	      error was	detected.  Also	see the	-s  or	--no-messages  option.
	      (-q is specified by POSIX.)

       -s, --no-messages
	      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 -q and its -s	option behaved
	      like GNU grep's -q option.  USG-style grep also  lacked  -q  but
	      its  -s  option  behaved	like GNU grep.	Portable shell scripts
	      should avoid both	-q and -s and  should  redirect	 standard  and
	      error  output to /dev/null instead.  (-s is specified by POSIX.)

   Output Line Prefix Control
       -b, --byte-offset
	      Print the	0-based	byte offset within the input file before  each
	      line of output.  If -o (--only-matching) is specified, print the
	      offset of	the matching part itself.

       -H, --with-filename
	      Print the	file name for each match.  This	is  the	 default  when
	      there is more than one file to search.

       -h, --no-filename
	      Suppress	the  prefixing	of  file names on output.  This	is the
	      default when there is only one file (or only standard input)  to
	      search.

       --label=LABEL
	      Display  input  actually	coming	from  standard	input as input
	      coming from file LABEL.  This is	especially  useful  for	 tools
	      like zgrep, e.g.,	gzip -cd foo.gz	| grep --label=foo something

       -n, --line-number
	      Prefix  each  line of output with	the 1-based line number	within
	      its input	file.  (-n is specified	by POSIX.)

       -T, --initial-tab
	      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.   In order to improve the probability
	      that lines from a	single file will all start at the same column,
	      this also	causes the line	number and byte	offset (if present) to
	      be printed in a minimum size field width.

       -u, --unix-byte-offsets
	      Report Unix-style	byte offsets.	This  switch  causes  grep  to
	      report  byte offsets as if the file were a Unix-style text file,
	      i.e., with  CR  characters  stripped  off.   This	 will  produce
	      results  identical  to  running  grep  on	 a Unix	machine.  This
	      option has no effect unless -b option is also used;  it  has  no
	      effect on	platforms other	than MS-DOS and	MS-Windows.

       -Z, --null
	      Output  a	 zero  byte  (the  ASCII NUL character)	instead	of the
	      character	that normally follows a	file name.  For	example,  grep
	      -lZ  outputs  a  zero  byte  after each file name	instead	of the
	      usual newline.  This option makes	the output  unambiguous,  even
	      in the presence of file names containing unusual characters like
	      newlines.	 This option can  be  used  with  commands  like  find
	      -print0,	perl  -0,  sort	 -z, and xargs -0 to process arbitrary
	      file names, even those that contain newline characters.

   Context Line	Control
       -A NUM, --after-context=NUM
	      Print NUM	 lines	of  trailing  context  after  matching	lines.
	      Places   a  line	containing  a  group  separator	 (--)  between
	      contiguous groups	of matches.  With the  -o  or  --only-matching
	      option, this has no effect and a warning is given.

       -B NUM, --before-context=NUM
	      Print  NUM  lines	 of  leading  context  before  matching	lines.
	      Places  a	 line  containing  a  group  separator	(--)   between
	      contiguous  groups  of  matches.	With the -o or --only-matching
	      option, this has no effect and a warning is given.

       -C NUM, -NUM, --context=NUM
	      Print NUM	lines of output	context.  Places a line	 containing  a
	      group separator (--) between contiguous groups of	matches.  With
	      the -o or	--only-matching	option,	 this  has  no	effect	and  a
	      warning is given.

   File	and Directory Selection
       -a, --text
	      Process  a binary	file as	if it were text; this is equivalent to
	      the --binary-files=text option.

       --binary-files=TYPE
	      If the first few bytes of	a file indicate	that the file contains
	      binary  data, assume that	the file is of type TYPE.  By default,
	      TYPE is binary, and grep	normally  outputs  either  a  one-line
	      message  saying  that  a	binary	file matches, or no message if
	      there is no match.  If TYPE is without-match, grep assumes  that
	      a	 binary	 file  does  not  match;  this is equivalent to	the -I
	      option.  If TYPE is text,	grep processes a binary	file as	if  it
	      were  text;  this	is equivalent to the -a	option.	 Warning: grep
	      --binary-files=text might	output binary garbage, which can  have
	      nasty  side  effects  if	the  output  is	 a terminal and	if the
	      terminal driver interprets some of it as commands.

       -D ACTION, --devices=ACTION
	      If an input file is a device, FIFO  or  socket,  use  ACTION  to
	      process  it.   By	 default,  ACTION  is  read,  which means that
	      devices are read just as if they were ordinary files.  If	ACTION
	      is skip, devices are silently skipped.

       -d ACTION, --directories=ACTION
	      If  an  input file is a directory, use ACTION to process it.  By
	      default, ACTION is read, which means that	directories  are  read
	      just  as	if  they  were	ordinary  files.   If  ACTION is skip,
	      directories are silently skipped.	 If ACTION  is	recurse,  grep
	      reads  all  files	 under	each  directory,  recursively; this is
	      equivalent to the	-r option.

       --exclude=GLOB
	      Skip  files  whose  base	name  matches  GLOB  (using   wildcard
	      matching).   A  file-name	 glob  can  use	 *,  ?,	 and [...]  as
	      wildcards, and \ to quote	 a  wildcard  or  backslash  character
	      literally.

       --exclude-from=FILE
	      Skip  files  whose  base name matches any	of the file-name globs
	      read from	FILE  (using  wildcard	matching  as  described	 under
	      --exclude).

       --exclude-dir=DIR
	      Exclude  directories  matching  the  pattern  DIR	from recursive
	      searches.

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

       --include=GLOB
	      Search  only  files whose	base name matches GLOB (using wildcard
	      matching as described under --exclude).

       -R, -r, --recursive
	      Read all	files  under  each  directory,	recursively;  this  is
	      equivalent to the	-d recurse option.

   Other Options
       --line-buffered
	      Use  line	 buffering  on	output.	  This can cause a performance
	      penalty.

       --mmap If possible, use the mmap(2) system call to read input,  instead
	      of  the default read(2) system call.  In some situations,	--mmap
	      yields better performance.  However, --mmap can cause  undefined
	      behavior	(including  core dumps)	if an input file shrinks while
	      grep is operating, or if an I/O error occurs.

       -U, --binary
	      Treat the	file(s)	as binary.  By default,	under MS-DOS  and  MS-
	      Windows,	grep  guesses the file type by looking at the contents
	      of the first 32KB	read from the file.  If	grep decides the  file
	      is  a  text  file, it strips the CR characters from the original
	      file contents (to	make regular expressions with  ^  and  $  work
	      correctly).  Specifying -U overrules this	guesswork, causing all
	      files to be read and passed to the matching mechanism  verbatim;
	      if  the  file is a text file with	CR/LF pairs at the end of each
	      line, this will cause some regular expressions  to  fail.	  This
	      option  has  no  effect  on  platforms other than	MS-DOS and MS-
	      Windows.

       -z, --null-data
	      Treat the	input as a set of lines, each  terminated  by  a  zero
	      byte  (the  ASCII	NUL character) instead of a newline.  Like the
	      -Z or --null option, this	option can be used with	commands  like
	      sort -z to process arbitrary file	names.

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 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 meta-character with
       special meaning may be quoted by	preceding it with a backslash.

       The period . matches any	single character.

   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.
       For  example,  the  regular  expression [0123456789] matches any	single
       digit.

       Within a	 bracket  expression,  a  range	 expression  consists  of  two
       characters separated by a hyphen.  It matches any single	character that
       sorts  between  the  two	 characters,  inclusive,  using	 the  locale's
       collating  sequence  and	 character set.	 For example, in the default C
       locale, [a-d] is	equivalent to [abcd].  Many locales sort characters in
       dictionary   order,  and	 in  these  locales  [a-d]  is	typically  not
       equivalent to [abcd]; it	might be equivalent to [aBbCcDd], for example.
       To  obtain  the	traditional interpretation of 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	within
       bracket expressions, as follows.	 Their names are self explanatory, and
       they   are   [:alnum:],	[:alpha:],  [:cntrl:],	[:digit:],  [:graph:],
       [:lower:], [:print:], [:punct:],	[:space:], [:upper:], and  [:xdigit:].
       For  example,  [[:alnum:]]  means  [0-9A-Za-z],	except the latter form
       depends upon the	C locale and the ASCII character encoding, whereas the
       former  is  independent	of  locale  and	character set.	(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
       expression.)  Most meta-characters lose their  special  meaning	inside
       bracket	expressions.   To  include  a  literal ] place it first	in the
       list.  Similarly, to include a literal ^	place it anywhere  but	first.
       Finally,	to include a literal - place it	last.

   Anchoring
       The caret ^ and the dollar sign $ are meta-characters that respectively
       match the empty string at the beginning and end of a line.

   The Backslash Character and Special Expressions
       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.	The symbol \w is a synonym for [[:alnum:]] and
       \W is a synonym for [^[:alnum:]].

   Repetition
       A regular expression 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 matched at most m times.
       {n,m}  The  preceding  item  is	matched	at least n times, but not more
	      than m times.

   Concatenation
       Two regular expressions may  be	concatenated;  the  resulting  regular
       expression  matches  any	 string	formed by concatenating	two substrings
       that respectively match the concatenated	expressions.

   Alternation
       Two regular expressions may be joined by	 the  infix  operator  |;  the
       resulting   regular  expression	matches	 any  string  matching	either
       alternate expression.

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

   Back	References and Subexpressions
       The back-reference \n, where n is a single digit, matches the substring
       previously matched  by  the  nth	 parenthesized	subexpression  of  the
       regular expression.

   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, so portable scripts should avoid  {
       in grep -E patterns and should use [{] to match a literal {.

       GNU grep	-E attempts to support traditional usage by assuming that { is
       not  special  if	 it  would  be	the  start  of	an  invalid   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.2 allows this behavior as an	extension, but
       portable	scripts	should avoid it.

ENVIRONMENT VARIABLES
       The  behavior  of  grep	is  affected  by  the  following   environment
       variables.

       The  locale  for	 category  LC_foo  is specified	by examining the three
       environment variables LC_ALL, LC_foo, LANG, in that order.   The	 first
       of  these  variables that is set	specifies the locale.  For example, if
       LC_ALL is not set, but LC_MESSAGES is set to pt_BR, then	the  Brazilian
       Portuguese  locale  is used for the 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	compiled with national
       language	support	(NLS).

       GREP_OPTIONS
	      This variable specifies default options to be placed in front of
	      any   explicit   options.	   For	example,  if  GREP_OPTIONS  is
	      '--binary-files=without-match --directories=skip', grep  behaves
	      as   if	the   two   options  --binary-files=without-match  and
	      --directories=skip  had  been  specified	before	any   explicit
	      options.	 Option	specifications are separated by	whitespace.  A
	      backslash	escapes	the next character,  so	 it  can  be  used  to
	      specify an option	containing whitespace or a backslash.

       GREP_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
	      highlight	 the  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
	      Specifies	 the  colors  and  other  attributes used to highlight
	      various parts of the output.  Its	 value	is  a  colon-separated
	      list	 of	  capabilities	    that      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 capability and	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 capability and	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  of  the
		     sl=  and cx= capabilities when 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 only used when the	-v command-line	option
		     is	 omitted.)   The  effect  of  the  sl=	(or cx=	if rv)
		     capability	 remains  active  when	this  kicks  in.   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 only used when the	-v command-line	option
		     is	specified.)  The effect	of the	cx=  (or  sl=  if  rv)
		     capability	 remains  active  when	this  kicks  in.   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 inserted between
		     selected line fields (:), between	context	 line  fields,
		     (-),  and	between	 groups	of adjacent lines when 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 line
		     using 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
		     terminals	for  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.

	      See   the	  Select   Graphic  Rendition  (SGR)  section  in  the
	      documentation of the text	terminal that is  used	for  permitted
	      values   and  their  meaning  as	character  attributes.	 These
	      substring	values are integers in decimal representation and  can
	      be  concatenated with semicolons.	 grep takes care of assembling
	      the result into 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.

       LC_ALL, LC_COLLATE, LANG
	      These variables specify the locale for the LC_COLLATE  category,
	      which  determines	the collating sequence used to interpret range
	      expressions like [a-z].

       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.

       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.2  requires;  otherwise,  grep
	      behaves  more  like  other  GNU programs.	 POSIX.2 requires that
	      options that follow file names must be treated as	file names; by
	      default,	such  options are permuted to the front	of the operand
	      list and are treated as options.	Also,  POSIX.2	requires  that
	      unrecognized  options  be	diagnosed as "illegal",	but since they
	      are not really against the law the default is to	diagnose  them
	      as      "invalid".       POSIXLY_CORRECT	    also      disables
	      _N_GNU_nonoption_argv_flags_, described below.

       _N_GNU_nonoption_argv_flags_
	      (Here N is grep's	numeric	process	ID.)  If the ith character  of
	      this  environment	variable's value is 1, do not consider the ith
	      operand of grep to be an option, even if it appears to  be  one.
	      A	 shell	can  put  this	variable  in  the environment for each
	      command it runs, specifying which	operands are  the  results  of
	      file name	wildcard expansion and therefore should	not be treated
	      as options.  This	behavior is available  only  with  the	GNU  C
	      library, and only	when POSIXLY_CORRECT is	not set.

EXIT STATUS
       Normally,  the  exit  status  is	 0  if	selected lines are found and 1
       otherwise.  But the exit	status is 2 if an error	occurred,  unless  the
       -q  or --quiet or --silent option is used and a selected	line is	found.
       Note, however, that POSIX only mandates,	for  programs  such  as	 grep,
       cmp, and	diff, that the exit status in case of error be greater than 1;
       it is therefore advisable, for the sake of portability,	to  use	 logic
       that  tests  for	 this  general	condition  instead  of strict equality
       with 2.

COPYRIGHT
       Copyright (C) 1998, 1999, 2000, 2002, 2005  Free	 Software  Foundation,
       Inc.

       This is free software; see the source for copying conditions.  There is
       NO warranty; not	even for MERCHANTABILITY or FITNESS FOR	 A  PARTICULAR
       PURPOSE.

BUGS
   Reporting Bugs
       Email  bug reports to <bug-grep@gnu.org>, a mailing list	whose web page
       is <http://lists.gnu.org/mailman/listinfo/bug-grep>.   grep's  Savannah
       bug tracker is located at <http://savannah.gnu.org/bugs/?group=grep>.

   Known Bugs
       Large  repetition  counts  in the {n,m} 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
       memory.

       Back-references are very	slow, and may require exponential time.

SEE ALSO
   Regular Manual Pages
       awk(1), cmp(1), diff(1),	find(1), gzip(1),  perl(1),  sed(1),  sort(1),
       xargs(1),   zgrep(1),   mmap(2),	  read(2),   pcre(3),  pcrepattern(3),
       terminfo(5), glob(7), regex(7).

   POSIX Programmer's Manual Page
       grep(1p).

   TeXinfo Documentation
       The full	documentation for grep is maintained as	a TeXinfo manual.   If
       the  info  and  grep  programs are properly installed at	your site, the
       command

	      info grep

       should give you access to the complete manual.

NOTES
       GNU's not Unix, but Unix	is a beast; its	plural form is Unixen.

GNU grep 2.5.1-cvs		  2008-02-07			       GREP(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | REGULAR EXPRESSIONS | ENVIRONMENT VARIABLES | EXIT STATUS | COPYRIGHT | BUGS | SEE ALSO | NOTES

Want to link to this manual page? Use this URL:
<http://www.freebsd.org/cgi/man.cgi?query=grep&manpath=SuSE+Linux%2fi386+11.3>

home | help