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 - search a file for	a pattern

SYNOPSIS
       /usr/bin/grep [-bchilnsvw] limited-regular-expression [filename...]

       /usr/xpg4/bin/grep  [-E	|  -F]	 [-c  |	 -l | -q]  [-bhinsvwx] -e pat-
       tern_list...  [-f pattern_file]... [file...]

       /usr/xpg4/bin/grep [-E |	-F]  [-c |  -l	|  -q]	 [-bhinsvwx]  [-e pat-
       tern_list...] -f	pattern_file...	[file...]

       /usr/xpg4/bin/grep  [-E	|  -F]	 [-c  |	 -l | -q]  [-bhinsvwx] pattern
       [file...]

DESCRIPTION
       The grep	utility	searches text files for	a pattern and prints all lines
       that  contain  that pattern.  It	uses a compact non-deterministic algo-
       rithm.

       Be careful using	the characters $, *, [,	^, |, (, ), and	\ in the  pat-
       tern_list  because  they	are also meaningful to the shell. It is	safest
       to enclose the entire pattern_list in single quotes  '... '.

       If no files are specified, grep assumes standard	input. Normally,  each
       line  found  is	copied	to  standard  output. The file name is printed
       before each line	found if there is more than one	input file.

   /usr/bin/grep
       The /usr/bin/grep utility uses limited regular expressions  like	 those
       described on the	regexp(5) manual page to match the patterns.

   /usr/xpg4/bin/grep
       The options -E and -F affect the	way /usr/xpg4/bin/grep interprets pat-
       tern_list. If  -E  is  specified,  /usr/xpg4/bin/grep  interprets  pat-
       tern_list as a full regular expression (see -E for description).	 If -F
       is specified, grep interprets pattern_list as a fixed string.  If  nei-
       ther  are  specified,  grep  interprets pattern_list as a basic regular
       expression as described on regex(5) manual page.

OPTIONS
       The  following  options	are  supported	for  both  /usr/bin/grep   and
       /usr/xpg4/bin/grep:

       -b    Precede each line by the block number on which it was found. This
	     can be useful in locating block numbers by	context	 (first	 block
	     is	0).

       -c    Print only	a count	of the lines that contain the pattern.

       -h    Prevents  the  name of the	file containing	the matching line from
	     being appended to that line.  Used	when searching multiple	files.

       -i    Ignore upper/lower	case distinction during	comparisons.

       -l    Print  only  the names of files with matching lines, separated by
	     NEWLINE characters.  Does not repeat the names of files when  the
	     pattern is	found more than	once.

       -n    Precede  each  line by its	line number in the file	(first line is
	     1).

       -s    Suppress error messages about nonexistent or unreadable files.

       -v    Print all lines except those that contain the pattern.

       -w    Search for	the expression as a word as if surrounded  by  \<  and
	     \>.

   /usr/xpg4/bin/grep
       The following options are supported for /usr/xpg4/bin/grep only:

       -e pattern_list
	     Specify  one  or  more  patterns to be used during	the search for
	     input. Patterns in	pattern_list must be separated	by  a  NEWLINE
	     character.	  A null pattern can be	specified by two adjacent new-
	     line characters in	pattern_list. Unless the -E or	-F  option  is
	     also  specified,  each pattern will be treated as a basic regular
	     expression.  Multiple -e and -f options are accepted by grep. All
	     of	 the  specified	patterns are used when matching	lines, but the
	     order of evaluation is unspecified.

       -E    Match using full regular expressions. Treat each  pattern	speci-
	     fied  as  a  full	regular	expression. If any entire full regular
	     expression	pattern	matches	 an  input  line,  the	line  will  be
	     matched.  A null full regular expression matches every line. Each
	     pattern will be interpreted  as  a	 full  regular	expression  as
	     described	on the regex(5)	manual page, except for	\( and \), and
	     including:

	     1.	A full regular expression followed by +	that  matches  one  or
		more occurrences of the	full regular expression.

	     2.	A  full	 regular  expression followed by ? that	matches	0 or 1
		occurrences of the full	regular	expression.

	     3.	Full regular expressions separated by |	or by a	new-line  that
		match strings that are matched by any of the expressions.

	     4.	A  full	regular	expression that	may be enclosed	in parentheses
		() for grouping.

	     The order of precedence of	operators is [], then *?+,  then  con-
	     catenation, then |	and new-line.

       -f pattern_file
	     Read  one	or  more patterns from the file	named by the path name
	     pattern_file. Patterns in pattern_file are	terminated by  a  NEW-
	     LINE character.  A	null pattern can be specified by an empty line
	     in	pattern_file. Unless the -E or -F option  is  also  specified,
	     each pattern will be treated as a basic regular expression.

       -F    Match  using  fixed  strings.  Treat  each	pattern	specified as a
	     string instead of a regular expression. If	an input line contains
	     any  of  the patterns as a	contiguous sequence of bytes, the line
	     will be matched. A	null string matches every line.	 See  fgrep(1)
	     for more information.

       -q    Quiet.  Do	 not write anything to the standard output, regardless
	     of	matching lines.	Exit with zero status  if  an  input  line  is
	     selected.

       -x    Consider  only input lines	that use all characters	in the line to
	     match an entire fixed string or regular expression	to be matching
	     lines.

OPERANDS
       The following operands are supported:

       file  A path name of a file to be searched for the patterns. If no file
	     operands are specified, the standard input	will be	used.

   /usr/bin/grep
       pattern
	     Specify a pattern to be used during the search for	input.

   /usr/xpg4/bin/grep
       pattern
	     Specify one or more patterns to be	used  during  the  search  for
	     input.  This operand is treated as	if it were specified as	-epat-
	     tern_list.

USAGE
       The -epattern_list option has the same effect as	the pattern_list oper-
       and,  but is useful when	pattern_list begins with the hyphen delimiter.
       It is also useful when it is more convenient to provide	multiple  pat-
       terns as	separate arguments.

       Multiple	 -e  and  -f options are accepted and grep will	use all	of the
       patterns	it is given while matching input text lines.  (Note  that  the
       order of	evaluation is not specified. If	an implementation finds	a null
       string as a pattern, it is allowed to use that pattern first,  matching
       every line, and effectively ignore any other patterns.)

       The  -q	option provides	a means	of easily determining whether or not a
       pattern (or string) exists in a group of	files. When searching  several
       files,  it  provides  a performance improvement (because	it can quit as
       soon as it finds	the first match) and requires less care	by the user in
       choosing	 the set of files to supply as arguments (because it will exit
       zero if it finds	a match	even if	grep detected an access	or read	 error
       on earlier file operands).

   Large File Behavior
       See  largefile(5)  for  the  description	 of  the behavior of grep when
       encountering files greater than or equal	to 2 Gbyte ( 2**31 bytes).

EXAMPLES
       Example 1: Finding all uses of a	word

       To find all uses	of the word "Posix" (in	any case) in the file text.mm,
       and write with line numbers:

       example%	/usr/bin/grep -i -n posix text.mm

       Example 2: Finding all empty lines

       To find all empty lines in the standard input:

       example%	/usr/bin/grep ^$

       or

       example%	/usr/bin/grep -v .

       Example 3: Finding lines	containing strings

       Both  of	 the following commands	print all lines	containing strings abc
       or def or both:

       example%	/usr/xpg4/bin/grep -E 'abc def'

       example%	/usr/xpg4/bin/grep -F 'abc def'

       Example 4: Finding lines	with matching strings

       Both of the following commands print all	lines matching exactly abc  or
       def:

       example%	/usr/xpg4/bin/grep -E '^abc$ ^def$'

       example%	/usr/xpg4/bin/grep -F -x 'abc def'

ENVIRONMENT VARIABLES
       See  environ(5) for descriptions	of the following environment variables
       that affect the execution of grep: LC_COLLATE,  LC_CTYPE,  LC_MESSAGES,
       and NLSPATH.

EXIT STATUS
       The following exit values are returned:

       0     One or more matches were found.

       1     No	matches	were found.

       2     Syntax errors or inaccessible files (even if matches were found).

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

   /usr/bin/grep
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |enabled			   |
       +-----------------------------+-----------------------------+

   /usr/xpg4/bin/grep
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWxcu4			   |
       +-----------------------------+-----------------------------+
       |CSI			     |enabled			   |
       +-----------------------------+-----------------------------+

SEE ALSO
       egrep(1), fgrep(1), sed(1), sh(1),  attributes(5),  environ(5),	large-
       file(5),	regex(5), regexp(5), XPG4(5)

NOTES
   /usr/bin/grep
       Lines  are limited only by the size of the available virtual memory. If
       there is	a line with embedded nulls, grep will only  match  up  to  the
       first null; if it matches, it will print	the entire line.

   /usr/xpg4/bin/grep
       The  results  are  unspecified if input files contain lines longer than
       LINE_MAX	 bytes	or  contain  binary  data.  LINE_MAX  is  defined   in
       /usr/include/limits.h.

SunOS 5.9			  20 Oct 1997			       grep(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | OPERANDS | USAGE | EXAMPLES | ENVIRONMENT VARIABLES | EXIT STATUS | ATTRIBUTES | SEE ALSO | NOTES

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=grep&manpath=SunOS+5.9>

home | help