egrep man page on Tru64

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
Tru64 logo
[printable version]

grep(1)								       grep(1)

NAME
       grep, egrep, fgrep - Searches a file for patterns

SYNOPSIS
       grep  [-E   | -F] [-c  | -l  | -q] [-bhinsvwxy] [-pparagraph_separator]
       -e pattern_list [-e pattern_list]... [-f pattern_file]... [file...]

       grep [-E	 | -F] [-c  | -l  | -q]	 [-bhinsvwxy]  [-pparagraph_separator]
       [-e pattern_list]... -f pattern_file [-f pattern_file]... [file...]

       grep  [-E   | -F] [-c  | -l  | -q] [-bhinsvwxy] [-pparagraph_separator]
       pattern_list [file...]

       The commands grep -E and grep -F are equivalent to the obsolescent com‐
       mands egrep and fgrep, respectively.

       The  grep  command  searches  the  specified  files  (standard input by
       default) for lines containing characters that match the specified  pat‐
       terns, and then writes matching lines to standard output.

STANDARDS
       Interfaces  documented on this reference page conform to industry stan‐
       dards as follows:

       grep:  XCU5.0

       egrep:  XCU5.0

       fgrep:  XCU5.0

       Refer to the standards(5) reference page	 for  more  information	 about
       industry standards and associated tags.

OPTIONS
       Although	 most options can be combined, some combinations result in one
       option overriding another. For example, if you specify -n and  -l,  the
       output  includes file names only (as specified by -l) and thus does not
       include line numbers (as specified by -n).  Treats patterns as extended
       regular expressions and is equivalent to the obsolescent egrep command.
       Treats patterns as fixed strings and is equivalent to  the  obsolescent
       fgrep command.  [Tru64 UNIX]  Precedes each line by the block number on
       which it was found.  Use this option to help find disk block numbers by
       context.	 Displays only a count of matching lines.  Used to specify one
       or more patterns to match. If more than one  pattern  is	 specified  in
       pattern_list,  they  must  be separated by newline characters (carriage
       returns). The -e option is useful for specifying a pattern that	begins
       with a - (dash).	 Specifies a file that contains patterns to match, one
       per line.  [Tru64 UNIX]	Suppresses reporting of file names when multi‐
       ple  files  are	processed.   That is, it prevents the name of the file
       containing the matching line from being appended to that line.  Ignores
       the  case of letters pattern matching; that is, uppercase and lowercase
       in the input are considered to be identical.  Lists only	 the  name  of
       each  file  containing  matched	lines.	 Each file name is listed only
       once; file names are separated by newline characters.  The grep command
       returns	(standard  input) (or the local equivalent) in place of a file
       name if -l is specified with standard input.  Precedes each  line  with
       its  relative  line  number  in	the  file.  [Tru64 UNIX]  Displays the
       entire paragraph containing matched lines. Paragraphs are delimited  by
       paragraph  separators,  paragraph_separator,  which are patterns in the
       same form as the search pattern.	 Lines containing the paragraph	 sepa‐
       rators are used only as separators; they are never included in the out‐
       put.  The default paragraph separator is a blank line.  Suppresses  all
       output except error messages. This is useful for checking status.  Sup‐
       presses error messages arising from non-existent or  unreadable	files.
       Other  error  messages  are still displayed.  Displays all lines except
       those that match the specified pattern.	Useful for filtering  unwanted
       lines  out  of a file.  [Tru64 UNIX]  Matches only if the expression is
       found as a separate word in the text. A word is any string of  alphanu‐
       meric characters (letters, numerals, and underscores) delimited by non‐
       alphanumeric characters (punctuation or white space) or by  the	begin‐
       ning  or end of the line). See ex.  Displays a line only if the pattern
       matches the entire line.	 [Tru64 UNIX]  Same as -i option.

OPERANDS
       Specify 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.  A
       path name of a file to be searched for the patterns. If no  file	 oper‐
       ands are specified, the standard input is used.

DESCRIPTION
       By  default,  the  grep	command	 treats	 a  pattern as a basic regular
       expression (BRE).  With the -E option, the pattern  is  treated	as  an
       extended	 regular  expression (ERE). With the -F option, the pattern is
       considered a fixed string. See  the  following  discussion  of  regular
       expressions.

       In  the output of the grep command, a matched line is preceded with the
       name of the file in which it was found if you  specify  more  than  one
       file (except when the -h option is specified).

       [Tru64  UNIX]  You  are strongly encouraged to single quote patterns to
       protect them from unwanted shell substitutions. In some cases, such  as
       in  multiline  pattern  lists and subexpressions, quoting is essential.
       When using the C shell interactively, you must enter a backslash before
       terminating a line in a multiline pattern.

       [Tru64 UNIX]  Running grep on a file that is not a text file (for exam‐
       ple, an file) produces unpredictable results and is discouraged.

NOTES
       The egrep and fgrep utility is marked LEGACY in XCU Issue 5.

REGULAR EXPRESSIONS
       Regular expressions (RE's) provide a powerful way to  specify  patterns
       to  search  for	in text files (or in the standard input). This section
       explains the rules for constructing such patterns.

       On Tru64 UNIX  there are two standard types of REs, and thus  two  sets
       of  rules  for building patterns. The two types of a regular expression
       that can be built by using these rules are termed either basic  regular
       expression (BRE) or extended regular expression (ERE). There is much in
       common between BREs and EREs, but there are  important  differences  as
       well.

       A variety of commands and utilities use one or the other type of RE, or
       both. Thus the rules described below are applicable in  many  contexts.
       Nonetheless, the grep command is used illustratively here.

       The  term  regular  expression, or RE, is used when there is no need to
       distinguish between BREs	 and  EREs.  The  terms	 pattern  and  regular
       expression  can	be  used  interchangeably.  The	 term match is used to
       describe a string in a file (or standard input)	that  is  successfully
       specified  by  a pattern or RE. A pattern or an RE may also be referred
       to as a string.	The matched string might also be termed a substring or
       a sequence (of characters).

       Simple  REs  match  a single character. More complex REs are built from
       other REs as explained in the rules below. REs are defined recursively;
       for example, if you concatenate two REs, the resultant string is an RE.

   Regular Expression Concepts
       The concept of a character is generalized to the concept of a collating
       element. For many purposes, especially in English-speaking locales, the
       term  collating	element	 may  be considered synonymous with character.
       Collating elements are relevant to bracket expressions,	and  are  dis‐
       cussed in the following sections.

       A collating element is the smallest unit used to determine how to order
       characters. They are necessary for languages that treat some strings as
       individual  collating elements. For example, in Spanish, the strings ch
       and ll each are collating symbols (that is, the	Spanish	 primary  sort
       order is a, b, c, ch, d,...,k, l, ll, m,...).

       As  an  example,	 suppose we have a file test that contains these three
       lines:

       ab acbcbc 12356

       The command grep 'b' test results in this output: ab acbcbc

       because the RE b, the pattern, matches the letter b in  the  first  and
       second lines of the file, and there is no b in the third line. The RE c
       would match just the second line. The RE bc, built by concatenating the
       prior two REs, would match just the second line.

       There  are  two	instances  of  bc  in  the second line, so the pattern
       matches the line. However, in using some of the rules that  build  REs,
       it  is important to understand exactly what substrings are matched by a
       pattern.

       Those rules are given in the following sections, but for	 illustration,
       consider	 the RE c.*b. This pattern means match a string beginning with
       c, ending with b, and with any number of characters between,  including
       none.   Thus  this  pattern  matches  lines  containing	cb,  cxb,  and
       canythingb, for example.

       The search for a match starts at the beginning of a  string  and	 stops
       when  the  first	 sequence  matching the pattern is found scanning from
       left to right. If there is more than one possible leftmost  match,  the
       longest match is used. For example, in the file test above, the pattern
       c.*b matches the second through third characters of  the	 second	 line,
       and also the second through the fifth characters. The latter, being the
       longer, is the actual match. However, a longer substring	 that  is  not
       the leftmost match is not a match.

       A null pattern will match any character, so the command

       grep '' test

       matches all three lines.

       A  multicharacter collating element is considered a single character in
       the rules below that describe how to form a bracket  expression,	 which
       matches	a single character. However, when considering what the longest
       sequence is in a match involving a  multicharacter  collating  element,
       the element counts not as one character but as the number of characters
       it matches.

       Pattern matching can be done in a case-insensitive manner.  Case-insen‐
       sitive processing permits matching of multicharacter collating elements
       as well as characters. For example, in grep -i '[[.Ch.]]' file

       the RE [[.Ch.]]	would match  ch,  Ch,  cH,  or	CH.  The  notation  is
       explained below.

       Some  utilities that use regular expressions, including grep, process a
       file line by line. A line ends with a newline  character.   In  general
       (but  not  with	grep  the newline character is regarded as an ordinary
       character and both a period and a nonmatching list can match one.  (See
       discussion below.) Some utilities, including grep, do not allow newline
       characters in a pattern to be matched.

   Basic Regular Expressions
       Basic regular expressions (BREs) are  built  by	concatenating  simpler
       BREs. BREs can be classified as those that can match a single character
       in the search string, and those that can match multiple characters.

       The following BREs match a single character (or collating element):

       An ordinary character, a special character preceded by a backslash,  or
       a period (.), matches a single character.  A bracket expression matches
       a single character or a	single	collating  element.  These  terms  are
       defined in the following sections.

       BRE Ordinary Characters

       Any  character,	except	for  those  listed in the section “BRE Special
       Characters,” below, is an ordinary character and is a BRE that  matches
       itself.

       Except for the following, do not quote ordinary characters with a back‐
       slash (\): The characters (, ), { and }. The use	 of  these  characters
       quoted  with backslashes is explained in the sections on subexpressions
       and interval expressions under  the  heading  “BREs  Matching  Multiple
       Characters,” following.	The digits 1 to 9 inclusive.  The use of these
       numerals quoted with backslashes is explained in the section  on	 back-
       reference expressions under the heading “BREs Matching Multiple Charac‐
       ters,” below.

       You can not use a backslash to  quote  a	 character  inside  a  bracket
       expression;  inside  a  bracket	expression  a backslash is an ordinary
       character.

       These characters, (, ), {, }, and 1 - 9 are considered “ordinary	 char‐
       acters” (see next section) because they do not have to be quoted with a
       backslash to match themselves as do “special characters.”

       BRE Special Characters

       Some characters have special meaning when used in a BRE	in  some  con‐
       texts,  defined	next.  Outside	such  contexts,	 or in the context but
       quoted with a preceding backslash, these	 characters  have  no  special
       meaning, and each is a BRE that matches itself. The BRE special charac‐
       ters and contexts are: The period, left bracket, and backslash are spe‐
       cial except when used in a bracket expression (discussed below). A pat‐
       tern containing a [ that is not preceded by a backslash and is not part
       of  a  bracket expression is not valid.	The asterisk is special except
       when used in a bracket expression, as the first character of a complete
       pattern	(after	an  initial ^, if any), or as the first character of a
       subexpression (after an initial ^ if any); The  circumflex  is  special
       when  used  as an anchor or as the first character of a bracket expres‐
       sion. These concepts are explained below.  The dollar sign  is  special
       when used as an anchor.

       Periods in BREs

       A  period  (.),	when  used outside a bracket expression, is a BRE that
       matches any character.

       BRE Bracket Expression

       A non-null string enclosed in  [	 ]  (brackets)	is  called  a  Bracket
       Expression. It is a BRE that matches any single character (or collating
       element) in the enclosed string. For example,  using  the  sample  file
       test described above, the command grep '[a3][c5]' test

       outputs	the  second and third lines, acbcbc and 12356, because the two
       contiguous bracket expressions in the pattern match the	substrings  ac
       and 35 in those lines.

       A  bracket  expression  is  either a matching list expression or a non‐
       matching list expression. It consists of one  or	 more  collating  ele‐
       ments,  collating  symbols,  equivalence	 classes, character classes or
       range expressions.

       The right bracket (]) loses its special meaning and  represents	itself
       in  a  bracket expression if it occurs first in the list (after an ini‐
       tial circumflex (^), if any).  Otherwise,  it  terminates  the  bracket
       expression,  unless  it appears in a collating symbol (such as [.].]  )
       or is the ending right bracket  for  a  collating  symbol,  equivalence
       class,  or  character  class. The special characters (period, asterisk,
       left bracket and	 backslash)  lose  their  special  meanings  within  a
       bracket expression.

       The  character  sequences  [.,  [=,  and [: (left bracket followed by a
       period, equal sign, or colon) are special inside a  bracket  expression
       and  are	 used  to delimit collating symbols, equivalence class expres‐
       sions and character class expressions.  These symbols must be  followed
       by  a valid expression and the matching terminating sequence =], or :],
       as defined next.

       The rules follow for creating and using matching and  nonmatching  list
       expressions,  collating symbol, equivalence class expression, character
       class expression, and range  expression,	 in  bracket  expressions.   A
       matching	 list expression, such as [a3] in the example above, specifies
       a list that matches any character or collating element in the list. The
       first  character	 in  the  list	can not be a circumflex.  [a3] matches
       either the character a or the character 3.  A nonmatching list  expres‐
       sion  begins  with  a circumflex (^), and specifies a list that matches
       any character or collating element except for the  expressions  in  the
       list  after  the	 leading circumflex. For example, [^abc] is a BRE that
       matches any character or collating element except the characters	 a,  b
       or  c. If the circumflex does not appear immediately following the left
       bracket, it loses its special meaning.  A collating symbol is a collat‐
       ing element enclosed within bracket-period ([. .]) delimiters. The con‐
       cept is introduced above under the  heading  “Regular  Expression  Con‐
       cepts.”

	      Multicharacter  collating	 elements are represented as collating
	      symbols to distinguish them from the  individual	characters  in
	      the collating symbol.  For example, when using Spanish collation
	      rules, [[.ch.]]  is treated as a BRE matching the	 sequence  ch,
	      while  [ch]  is  treated as an BRE matching c or h. In addition,
	      [a-[.ch.]]  matches a, b, c, and	ch.  (See  range  expressions,
	      below.)  Collating symbols are valid only inside bracket expres‐
	      sions.  An equivalence class expression specifies a set of  col‐
	      lating  elements	that all sort to the same primary location. An
	      equivalence class is enclosed in bracket-equal  ([=  =])	delim‐
	      iters.

	      An equivalence class generally is designed to deal with primary-
	      secondary sorting; that is,  for	languages  like	 French,  that
	      define groups of characters as sorting to the same primary loca‐
	      tion, and then having a tie-breaking, secondary sort.

	      For example, if x, y, and z are collating elements  that	belong
	      to  the  same  equivalence  class,  then the bracket expressions
	      [[=x=]a], [[=y=]a], and [[=z=]a] are equivalent to [xyza]. (Here
	      we  use  x, y, and z as variables representing characters in the
	      same equivalence class; in a typical example,  x	might  be  the
	      collating	 element e, and y and z the characters e with an acute
	      accent and e with a grave accent.)   If  the  collating  element
	      within [= =] delimiters does not belong to an equivalence class,
	      the equivalence class expression is treated as a collating  sym‐
	      bol,  that  is,  the  delimiters are ignored.  A character class
	      expression enclosed in bracket-colon [:  :]  delimiters  matches
	      any of the set of characters in the named class. Members of each
	      of the sets  are	determined  by	the  current  setting  of  the
	      LC_CTYPE environment variable. The supported classes are: alpha,
	      upper, lower, digit, alnum, xdigit, space, print, punct,	graph,
	      and  cntrl.  Here	 is  an example of how to specify one of these
	      classes: [[:lower:]]

	      This matches any single  lowercase  character  for  the  current
	      locale.  A range expression represents the set of collating ele‐
	      ments that fall between two elements in  the  current  collation
	      sequence,	 inclusively.  It  is expressed as starting and ending
	      points separated by a hyphen (-). For example, the BRE  1[a-d]2,
	      which  includes  the  bracket  expression	 [a-d], containing the
	      range expression a-d, represents a pattern that will  match  any
	      of these strings: 1a2, 1b2, 1c2, and 1d2.

	      Range  expressions  should  not be used in portable applications
	      because their behavior depends on collating sequences.

	      A construction such as [a-d-g] is invalid.

	      The hyphen character loses its  special  meaning	in  a  bracket
	      expression  if  it  occurs first (after an initial ^, if any) or
	      last, or as an ending range point in  a  range  expression.  For
	      example,	the  expressions  [-df]	 and  [df-] are equivalent and
	      match any of the characters d, f, or -. The  expressions	[^-df]
	      and  [^df-]  are equivalent and match any characters except d, f
	      and -; the expression [&--] matches any character between &, and
	      -	 inclusive; the expression [--;] matches any of the characters
	      between - and ; inclusive; and the expression [A--] is  invalid,
	      because A follows - in the collation sequence. A hyphen or right
	      bracket may be  represented  as  collating  symbols,  [.-.]   or
	      [.].],  anywhere	in  a bracket expression; Otherwise, if both -
	      and ] are required in a  bracket	expression,  bracket  must  be
	      first (after an optional initial ^) and the hyphen last.

       BREs Matching Multiple Characters

       The  rules  above describe how to construct a BRE that matches a single
       character. In some of the examples above, patterns that match  multiple
       characters  were given based on the intuitive concept of concatenation.
       This, and the other rules used to build BREs which match multiple char‐
       acters from BREs matching single characters, follow.  The concatenation
       of BREs matches the concatenation of the strings matched by each compo‐
       nent  of	 the  BRE.   A	subexpression  can  be defined within a BRE by
       enclosing it between the character pairs \( and \).  Such a  subexpres‐
       sion matches whatever it would have matched without the \( and \).

	      Up  to  nine subexpressions are saved into numbered holding spa‐
	      ces. Counting from left to right on the line, the first  pattern
	      saved  is	 placed in the first holding space, the second pattern
	      is placed in the second holding space, and so on.

	      The character sequence \n, called a  back-reference  expression,
	      matches  the  nth	 saved	pattern,  which	 is in the nth holding
	      space. (The value of n is a digit, 1-9.)	Thus, the pattern:

	      \(a\)\(b\)c\2\1

	      matches the string abcba. You can nest patterns to be  saved  in
	      holding  spaces. Whether the enclosed patterns are nested or are
	      in a series, \n refers to the nth occurrence, counting from  the
	      left,  of	 the  delimiting characters \). In utilities that have
	      replacement as well as search patterns, you can use  \n  expres‐
	      sions  in	 the replacement strings as well as in the search pat‐
	      terns.

	      A back-reference expression is invalid if less than n subexpres‐
	      sions precede the \n.  Finally, any number of subexpressions are
	      allowed in a search pattern even though the number of  back-ref‐
	      erence  expressions  is  limited	to nine.  If a BRE x matches a
	      single character, or is a	 subexpression	or  a  back-reference,
	      then the pattern x* (x followed by an asterisk), matches zero or
	      more occurrences of the character that the BRE  x	 matches.  For
	      example, this pattern:

	      ab*cd

	      matches each of these strings:

	      acd abcd abbcd abbbcd

	      but not this string:

	      abd  A  BRE that matches a single character, or that is a subex‐
	      pression or a back-reference, followed by an interval expression
	      of  the  format  \{i\}, \{i,\} or \{i,j\}, matches what repeated
	      consecutive occurrences of the BRE would match. Such a BRE  fol‐
	      lowed by: matches exactly i occurrences of the character matched
	      by the BRE matches at  least  i  occurrences  of	the  character
	      matched  by  the	BRE  matches  any number of occurrences of the
	      character matched by the BRE from i to j, inclusive.

	      The values of i and j must be integers in the range 0 <= i <=  j
	      <=  255.	Whenever  a choice exists, the pattern matches as many
	      occurrences as possible.

	      Note that if i is 0 (zero), the interval expression  is  equiva‐
	      lent to the null BRE.

       BRE Expression Anchoring--Restricting What Patterns Match

       A pattern (an entire BRE) can be restricted to match from the beginning
       of a line, restricted to match up to the end of the line, or restricted
       to match the entire line. This is done by anchoring the search pattern.
       A ^ (circumflex) at the beginning of  an	 expression  or	 subexpression
       causes  the  pattern  to	 match	only a string that begins in the first
       character position on a line. For example, the pattern ^bc  matches  bc
       in  the	line  bcdef  but doesn't match bc in abcdef. The subexpression
       \(^bc\) also matches bcdef.  A $ (dollar sign) at the end of a  pattern
       causes  that pattern to match only if the last matched character is the
       last character (not including the newline character) on	a  line.   The
       construction ^pattern$ restricts the pattern to matching only an entire
       line. For example, the BRE ^abcd$ matches lines containing  the	string
       abcd, where a is the first character on the line and d the last.

       BRE Precedence

       The  order of precedence, for high to low, is as shown in the following
       table:

       collation-related bracket symbols   [= =] [: :] [. .]
       escaped characters		   \<special character>
       bracket expressions		   [ ]
       subexpressions/back-references	   \( \) \n
       single-character duplication	   * \{i,j\}
       concatenation
       anchoring			   ^ $

   Extended Regular Expressions
       Like BREs, extended regular expressions (EREs) are built by concatenat‐
       ing simpler EREs. EREs can be classified as those that can match a sin‐
       gle character, and those that can match multiple characters.

       An ERE ordinary character, an ERE special character preceded by a back‐
       slash,  or  a  period  matches a single character. A bracket expression
       matches a single character or a single collating element. An ERE match‐
       ing  a  single  character enclosed in parentheses (a group) matches the
       same strings as the ERE without parentheses.

       ERE Ordinary Characters

       Any character, except for special characters listed below, is an	 ordi‐
       nary character and is an ERE that matches itself.

       ERE Special Characters

       Some  characters	 have  special meaning when used in a ERE in some con‐
       texts, defined next. Outside such  contexts,  or	 in  the  context  but
       quoted  with  a	preceding  backslash,  these character have no special
       meaning, and each is a ERE that matches itself. The ERE special charac‐
       ters  and  contexts  are:  The period, left bracket, backslash and left
       parenthesis are special except when used in a bracket expression.  Out‐
       side  a bracket expression, do not use a left parenthesis, (, unless it
       is quoted with a backslash, \(.	The right parenthesis is special  when
       matched	with  a	 preceding left parenthesis, outside a bracket expres‐
       sion. To search for the string (), use the quoted form \().  The aster‐
       isk,  plus  sign, question mark, and left brace are special except when
       used in a bracket expression. Outside of a bracket  expression,	it  is
       invalid to use any of them as the first character in an ERE, or immedi‐
       ately following a vertical line, a circumflex, or a  left  parenthesis.
       It  is  invalid	to  use	 a  left brace that is not part of an interval
       expression. (Of course, quoting with a backslash removes such  invalid‐
       ity.)   The  vertical  line  is	special	 except when used in a bracket
       expression. It is invalid to use a vertical line first or  last	in  an
       ERE, or immediately following another vertical line or a left parenthe‐
       sis, or immediately preceding a right parenthesis.  The	circumflex  is
       special	when  used as an anchor or as the first character of a bracket
       expression.  The dollar sign is special when used as an anchor.

       Periods in EREs

       A period (.), when used outside a bracket expression, is	 an  ERE  that
       matches any character.

       ERE Bracket Expression

       The  rules  for	ERE  Bracket  Expressions  are the same as for the BRE
       bracket expressions discussed above.

       EREs Matching Multiple Characters

       The rules above describe how to construct an ERE that matches a	single
       character. The rules used to build EREs which match multiple characters
       from EREs matching single characters follow.  A concatenation  of  EREs
       matches	the  concatenation of the strings matched by each component of
       the ERE. A concatenation of EREs enclosed in parentheses, matches what‐
       ever  the  concatenation without the parentheses matches.  For example,
       both EREs ab and (ab) match the second  and  third  characters  of  the
       string cabcdabc.	 An ERE matching a single character or an ERE enclosed
       in parentheses followed by the special character plus sign (+)  matches
       what  one  or  more consecutive occurrences of the ERE would match. For
       example, the ERE (ab)a+ matches the second to sixth  character  in  the
       string  cabaaabc	 and c(ab)+ matches the first to seventh characters in
       the string cabababc.  An ERE matching a	single	character  or  an  ERE
       enclosed	 in parentheses followed by the special character asterisk (*)
       matches what zero or more consecutive  occurrences  of  the  ERE	 would
       match.  For  example,  the  ERE	b*c matches the first character in the
       string cabbbcde, and the ERE c*de matches the second to	sixth  charac‐
       ters in the string dcccdec. The EREs [cd]+ and [cd][cd]* are equivalent
       and [cd]* and [cd][cd] are equivalent when matching the string cd.   An
       ERE  matching a single character or an ERE enclosed in parentheses fol‐
       lowed by the special character question mark (?) matches what  zero  or
       one consecutive occurrence of the ERE would match. For example, the ERE
       c?d matches the third character in the string abdbcccde.	 An ERE match‐
       ing a single character or an ERE enclosed in parentheses followed by an
       interval expression of the format {i}, {i,},  or	 {i,j},	 matches  what
       repeated	 consecutive occurrences of the ERE would match. The rules for
       matching are the same as for BRE interval expressions (discussed above)
       except for the notational difference.

	      For example, the ERE d{3} matches characters eight through 10 in
	      the string abcbcbcddddde and the ERE (bc){2,} matches characters
	      two to seven.

       ERE Alternation

       If x and y are EREs, then x|y is an ERE that matches any string that is
       matched by either x or y. For example, the ERE  ((cd)|e)b  matches  the
       string  cdb and the string eb. Single characters, or expressions match‐
       ing single characters, separated by the vertical bar  and  enclosed  in
       parentheses, match a single character.

       ERE Expression Anchoring

       ERE anchoring is the same as BRE anchoring, discussed above.

       ERE Precedence

       The  order of precedence, for high to low, is as shown in the following
       table:

       collation-related bracket symbols    [= =] [: :] [. .]
       escaped characters		   \<special character>
       bracket expression		   [ ]
       grouping				   ( )
       single-character duplication	   * + ? {i,j}
       concatenation
       anchoring			   ^ $
       alternation			   |

       For example, the pattern ab|cd is the same  as  (ab)|(cd)  and  is  not
       equivalent to a(b|c)d.

EXIT STATUS
       The  exit  values of the grep command are: A match was found.  No match
       was found.  A syntax error was found or a file was  inaccessible,  even
       if matches were found.

EXAMPLES
       To  search  several  C-language	source	files  for the pattern strcpy,
       enter: grep 'strcpy' *.c

	      This searches for the string strcpy in all files in the  current
	      directory with names ending in To count the number of lines that
	      match a pattern, enter: grep -F -c '{'  pgm.c  grep  -F  -c  '}'
	      pgm.c

	      This displays the number of lines in pgm.c that contain left and
	      right braces.

	      If you do not put more than one { or } on a line in your C  pro‐
	      grams,  and  if  the  braces are properly balanced, then the two
	      numbers displayed will be the same. If the numbers are  not  the
	      same,  then  you	can display the lines that contain braces with
	      the command: grep -n -E '\{|}' pgm.c To display all lines	 in  a
	      file  that  begin	 with an ASCII letter, enter: grep '^[a-zA-Z]'
	      pgm.s

	      Note that because grep -F searches only for  fixed  strings  and
	      does  not use regular expressions such as bracket expressions or
	      anchoring, the following command causes grep to search only  for
	      the literal string ^[a-zA-Z] in pgm.s: grep -F '^[a-zA-Z]' pgm.s
	      To display all lines that contain ASCII letters  in  parentheses
	      or  digits  in parentheses (with spaces optionally preceding and
	      following the letters or digits), but not letter-digit  combina‐
	      tions  in	 parentheses,  enter: grep -E '\(  *([a-zA-Z]*|[0-9]*)
	      *\)' my.txt

	      This command displays lines in my.txt such as (  783902) or (y),
	      but not (alpha19c).

	      Note  that with grep -E, \( and \) match parentheses in the text
	      and ( and ) are special characters that group parts of the  pat‐
	      tern.  With grep without the -E option, the reverse is true; use
	      ( and ) to match parentheses and \( and \) to group  characters.
	      To  display  all	lines that do not match a pattern, enter: grep
	      -v '^#'

	      This displays all lines that do  not  begin  with	 a  #  (number
	      sign).   To  display  the names of files that contain a pattern,
	      enter: grep -F -l 'rose' *.list

	      This searches the files in the current directory that  end  with
	      and  displays the names of those files that contain at least one
	      line containing the string rose.	To display all lines that con‐
	      tain uppercase characters, enter: grep [[:upper:]] pgm.s To dis‐
	      play all lines that  begin  with	a  range  of  characters  that
	      includes	 a   multicharacter   collating	 symbol,  enter:  grep
	      '^[a-[.ch.]]' pgm.s

	      With your locale set to a Spanish locale, this  command  matches
	      all lines that begin with a, b, c, or ch.

ENVIRONMENT VARIABLES
       The  following  environment  variables  affect  the  execution of grep,
       egrep, and fgrep: Provides a default value for the internationalization
       variables  that are unset or null. If LANG is unset or null, the corre‐
       sponding value from the default locale is used.	If any of the interna‐
       tionalization variables contain an invalid setting, the utility behaves
       as if none of the variables had been defined.  If  set  to  any	string
       value, overrides the values of all the other internationalization vari‐
       ables.  Determines the locale for the interpretation  of	 sequences  of
       bytes  of  text data as characters (for example, single-byte as opposed
       to multibyte characters in arguments and input files) and the  behavior
       of  character  classes  within  regular	expressions..	Determines the
       locale for the format and contents of diagnostic	 messages  written  to
       standard	 error.	 Determines the location of message catalogues for the
       processing of LC_MESSAGES.

SEE ALSO
       Commands:  ed(1), ex(1), ksh(1), sed(1),	 Bourne	 shell	sh(1b),	 POSIX
       shell sh(1p)

       Standards:  standards(5)

								       grep(1)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Tru64

List of man pages available for Tru64

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net