unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (SunOS-5.10)
Page:
Section:
Apropos / Subsearch:
optional field

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       Precedes  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       Prints 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  multi-
                ple files.



       -i       Ignores upper/lower case distinction during comparisons.



       -l       Prints  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       Precedes  each line by its line number in the file (first line
                is 1).



       -s       Suppresses error  messages  about  nonexistent  or  unreadable
                files.



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



       -w       Searches  for  the expression as a word as if surrounded by \<&lt;
                and \>&gt;.



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

       -e pattern_list Specifies one or more patterns to be  used  during  the
                       search for input. Patterns in pattern_list must be sep-
                       arated by a NEWLINE character. A null  pattern  can  be
                       specified  by  two  adjacent newline characters in pat-
                       tern_list. Unless the -E or -F option  is  also  speci-
                       fied,  each  pattern  is  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 unspeci-
                       fied.



       -E              Matches  using  full  regular  expressions. Treats each
                       pattern specified 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 is inter-
                       preted as a full regular expression as described on the
                       regex(5) manual page, except for \( and \), and includ-
                       ing:

                           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 concatenation, then | and new-line.



       -f pattern_file Reads one or more patterns from the file named  by  the
                       path  name  pattern_file.  Patterns in pattern_file are
                       terminated by a NEWLINE 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  is
                       treated as a basic regular expression.



       -F              Matches using fixed strings. Treats each pattern speci-
                       fied 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 infor-
                       mation.



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



       -x              Considers 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         Specifies a pattern to be used during  the  search  for
                       input.



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



USAGE
       The  -e pattern_list option has the same effect as the pattern_list op-
       erand, but is useful when pattern_list begins with  the  hyphen  delim-
       iter.  It is also useful when it is more convenient to provide multiple
       patterns 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. Notice 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

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

       example% /usr/xpg4/bin/grep 'abc
       def'
       example% /usr/xpg4/bin/grep -e 'abc
       def'
       example% /usr/xpg4/bin/grep -e 'abc' -e 'def'
       example% /usr/xpg4/bin/grep -E 'abc|def'
       example% /usr/xpg4/bin/grep -E -e 'abc|def'
       example% /usr/xpg4/bin/grep -E -e 'abc' -e 'def'
       example% /usr/xpg4/bin/grep -E 'abc
       def'
       example% /usr/xpg4/bin/grep -E -e 'abc
       def'
       example% /usr/xpg4/bin/grep -F -e 'abc' -e 'def'
       example% /usr/xpg4/bin/grep -F 'abc
       def'
       example% /usr/xpg4/bin/grep -F -e '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: LANG, LC_ALL, 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
       tab()     allbox;     cw(2.750000i)|    cw(2.750000i)    lw(2.750000i)|
       lw(2.750000i).   ATTRIBUTE  TYPEATTRIBUTE   VALUE   AvailabilitySUNWcsu
       CSIenabled


   /usr/xpg4/bin/grep
       tab()     allbox;     cw(2.750000i)|    cw(2.750000i)    lw(2.750000i)|
       lw(2.750000i).   ATTRIBUTE  TYPEATTRIBUTE  VALUE   AvailabilitySUNWxcu4
       CSIenabled Interface StabilityStandard


SEE ALSO
       egrep(1),  fgrep(1),  sed(1),  sh(1), attributes(5), environ(5), large-
       file(5), regex(5), regexp(5), standards(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 the line matches, the entire line will be printed.

   /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.10                        30 Aug 2002                          grep(1)