unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

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

GREP(1V)                                                              GREP(1V)



NAME
       grep, egrep, fgrep - search a file for a string or regular expression

SYNOPSIS
       grep [ -bchilnsvw ] [ -e expression ] [ filename... ]

       egrep [ -bchilnsv ] [ -e expression ] [ -f filename ]
            [ expression ] [ filename... ]

       fgrep [ -bchilnsvx ] [ -e string ] [ -f filename ]
            [ string ] [ filename... ]

SYSTEM V SYNOPSIS
       /usr/5bin/grep [ -bchilnsvw ] [ -e expression ]
            [ filename... ]

AVAILABILITY
       The  System  V  version  of this command is available with the System V
       software installation option.  Refer  to  for  information  on  how  to
       install optional software.

DESCRIPTION
       Commands  of  the  grep family search the input filenames (the standard
       input default) for lines matching a pattern.  Normally, each line found
       is  copied  to  the standard output.  grep patterns are limited regular
       expressions in the style of ed(1).  egrep  patterns  are  full  regular
       expressions including alternation.  fgrep patterns are fixed strings --
       no regular expression metacharacters are supported.

       In general, egrep is the fastest of these programs.

       Take care when using the characters `$', `*', [, `^',  `|',  `(',  `)',
       and  `\'  in the expression, as these characters are also meaningful to
       the shell.  It is safest to enclose the entire expression  argument  in
       single quotes '...'.

       When  any of the grep utilities is applied to more than one input file,
       the name of the file is displayed preceding each line which matches the
       pattern.   The filename is not displayed when processing a single file,
       so if you actually want the filename to appear, use /dev/null as a sec-
       ond file in the list.

OPTIONS
       -b     Precede  each  line  by  the block number on which it was found.
              This is sometimes useful in locating disk block numbers by  con-
              text.

       -c     Display  a  count  of  matching lines rather than displaying the
              lines which match.

       -h     Do not display filenames.

       -i     Ignore the case of letters in making  comparisons  --  that  is,
              upper and lower case are considered identical.

       -l     List  only  the  names of files with matching lines (once) sepa-
              rated by NEWLINE characters.

       -n     Precede each line by its relative line number in the file.

       -s     Work silently, that is, display nothing except  error  messages.
              This is useful for checking the error status.

       -v     Invert the search to only display lines that do not match.

       -w     Search  for  the expression as a word as if surrounded by \<&lt; and
              \>&gt;.  This applies to grep only.

       -x     Display only those lines which match exactly --  that  is,  only
              lines  which  match  in  their  entirety.  This applies to fgrep
              only.

       -e expression
              Same as a  simple  expression  argument,  but  useful  when  the
              expression begins with a `-'.

       -e string
              For fgrep the argument is a literal character string.

       -f filename
              Take  the  regular expression (egrep) or a list of strings sepa-
              rated by NEWLINE (fgrep) from filename.

SYSTEM V OPTIONS
       The -s option to grep indicates that error messages for nonexistent  or
       unreadable files should be suppressed, not that all messages except for
       error messages should be suppressed.

REGULAR EXPRESSIONS
       The following one-character regular expressions match a single  charac-
       ter:

       c      An  ordinary  character  (not one of the special characters dis-
              cussed below) is a one-character regular expression that matches
              that character.

       \c     A backslash (\) followed by any special character is a one-char-
              acter regular expression  that  matches  the  special  character
              itself.  The special characters are:

                     o      `.',  `*',  `[',  and  `\' (period, asterisk, left
                            square  bracket,  and  backslash,   respectively),
                            which  are always special, except when they appear
                            within square brackets ([]).

                     o      `^' (caret or circumflex), which is special at the
                            beginning of an entire regular expression, or when
                            it immediately follows  the  left  of  a  pair  of
                            square brackets ([]).

                     o      $  (currency  symbol), which is special at the end
                            of an entire regular expression.

       A backslash followed by one of `<&lt;', `>&gt;', `(', `)', `{', or `}',  repre-
       sents a special operator in the regular expression; see below.

       .      A  `.'   (period)  is  a  one-character  regular expression that
              matches any character except NEWLINE.

       [string]
              A non-empty string of characters enclosed in square brackets  is
              a  one-character regular expression that matches any one charac-
              ter in that string.  If, however, the  first  character  of  the
              string is a `^' (a circumflex or caret), the one-character regu-
              lar expression matches any  character  except  NEWLINE  and  the
              remaining  characters  in  the string.  The `^' has this special
              meaning only if it occurs first in the string.  The `-'  (minus)
              may be used to indicate a range of consecutive ASCII characters;
              for example, [0-9] is equivalent to [0123456789].  The `-' loses
              this  special  meaning if it occurs first (after an initial `^',
              if any) or last in the string.  The `]' (right  square  bracket)
              does  not terminate such a string when it is the first character
              within it (after an  initial  `^',  if  any);  that  is,  []a-f]
              matches  either `]' (a right square bracket ) or one of the let-
              ters a through f inclusive.  The four characters `.', `*',  `[',
              and `\' stand for themselves within such a string of characters.

       The following rules may be used to construct regular expressions:

       *      A one-character regular expression followed by `*' (an asterisk)
              is a regular expression that matches zero or more occurrences of
              the  one-character  regular expression.  If there is any choice,
              the longest leftmost string that permits a match is chosen.

       \(and\)
              A regular expression enclosed between the character sequences \(
              and   \)  matches  whatever  the  unadorned  regular  expression
              matches.  This applies only to grep.

       \n     The expression \n matches the same string of characters  as  was
              matched  by  an expression enclosed between \( and \) earlier in
              the same regular expression.  Here n is a digit; the sub-expres-
              sion  specified  is that beginning with the nth occurrence of \(
              counting from the left.  For example, the expression  ^\(.*\)\1$
              matches  a  line  consisting  of two repeated appearances of the
              same string.

   Concatenation
       The concatenation of regular expressions is a regular  expression  that
       matches  the  concatenation of the strings matched by each component of
       the regular expression.

       \<&lt;     The sequence \<&lt; in a regular expression constrains the one-char-
              acter  regular expression immediately following it only to match
              something at the beginning of a "word"; that is, either  at  the
              beginning  of  a line, or just before a letter, digit, or under-
              line and after a character not one of these.

       \>&gt;     The sequence \>&gt; in a regular expression constrains the one-char-
              acter  regular expression immediately following it only to match
              something at the end of a "word"; that is, either at the end  of
              a  line,  or  just before a character which is neither a letter,
              digit, nor underline.

       \{m\}
       \{m,\}
       \{m,n\}
              A regular expression  followed  by  \{m\},  \{m,\},  or  \{m,n\}
              matches  a  range of occurrences of the regular expression.  The
              values of m and n must be non-negative integers less  than  256;
              \{m\}  matches  exactly m occurrences; \{m,\} matches at least m
              occurrences; \{m,n\} matches any number of occurrences between m
              and  n inclusive.  Whenever a choice exists, the regular expres-
              sion matches as many occurrences as possible.

       ^      A circumflex or caret (^) at the beginning of an entire  regular
              expression  constrains  that regular expression to match an ini-
              tial segment of a line.

       $      A currency symbol ($) at the end of an entire regular expression
              constrains that regular expression to match a final segment of a
              line.

       The construction

              example% ^entire regular expression $

       constrains the entire regular expression to match the entire line.

       egrep accepts regular expressions of the same sort  grep  does,  except
       for \(, \), \n, \<&lt;, \>&gt;, \{, and \}, with the addition of:

                     *      A  regular  expression  (not  just a one-character
                            regular expression) followed by `*' (an  asterisk)
                            is  a regular expression that matches zero or more
                            occurrences of the one-character  regular  expres-
                            sion.   If  there is any choice, the longest left-
                            most string that permits a match is chosen.

                     +      A regular expression followed by `+' (a plus sign)
                            is  a  regular expression that matches one or more
                            occurrences of the one-character  regular  expres-
                            sion.   If  there is any choice, the longest left-
                            most string that permits a match is chosen.

                     ?      A regular expression followed by `?'  (a  question
                            mark) is a regular expression that matches zero or
                            one  occurrences  of  the  one-character   regular
                            expression.   If  there is any choice, the longest
                            leftmost string that permits a match is chosen.

                     |      Alternation: two regular expressions separated  by
                            `|'  or NEWLINE match either a match for the first
                            or a match for the second.

                     ()     A  regular  expression  enclosed  in   parentheses
                            matches a match for the regular expression.

       The  order  of precedence of operators at the same parenthesis level is
       `[ ]' (character classes), then `*' `+' `?'  (closures),then concatena-
       tion, then `|' (alternation)and NEWLINE.

EXAMPLES
       Search a file for a fixed string using fgrep:

              example% fgrep intro /usr/share/man/man3/*.3*

       Look for character classes using grep:

              example% grep '[1-8]([CJMSNX])' /usr/share/man/man1/*.1

       Look for alternative patterns using egrep:

              example% egrep '(Sally|Fred) (Smith|Jones|Parker)' telephone.list

       To  get  the filename displayed when only processing a single file, use
       /dev/null as the second file in the list:

              example% grep 'Sally Parker' telephone.list /dev/null

FILES
       /dev/null

SEE ALSO
       awk(1), ed(1), ex(1), sh(1), vi(1), sed(1V)

BUGS
       Lines are limited to 1024 characters by grep; longer  lines  are  trun-
       cated.

       The  combination  of -l and -v options does not produce a list of files
       in which a regular expression is not found.  To get such  a  list,  use
       the Bourne shell construct:

               for filename in *
               do
                       if [ `grep "re" $filename | wc -l` -eq 0 ]
                       then
                               echo $filename
                       fi
               done

       or the C shell construct:

               foreach filename (*)
                       if (`grep "re" $filename | wc -l` == 0) echo $filename
               end

       Ideally there should be only one grep.

DIAGNOSTICS
       Exit  status  is  0  if  any matches are found, 1 if none, 2 for syntax
       errors or inaccessible files.





                               30 November 1988                       GREP(1V)