Changes to doc/regexprops-generic.texi

[Gary V. Vaughan]

CVSROOT:        /sources/m4
Module name:    m4
Changes by:     Gary V. Vaughan <gary>  06/07/13 23:35:16

Index: doc/regexprops-generic.texi
===================================================================
RCS file: doc/regexprops-generic.texi
diff -N doc/regexprops-generic.texi
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ doc/regexprops-generic.texi 13 Jul 2006 23:35:16 -0000      1.1
@@ -0,0 +1,703 @@
address@hidden
+* awk regular expression syntax::
+* egrep regular expression syntax::
+* ed regular expression syntax::
+* emacs regular expression syntax::
+* gnu-awk regular expression syntax::
+* grep regular expression syntax::
+* posix-awk regular expression syntax::
+* posix-basic regular expression syntax::
+* posix-egrep regular expression syntax::
+* posix-extended regular expression syntax::
+* posix-minimal-basic regular expression syntax::
+* sed regular expression syntax::
address@hidden menu
+
address@hidden awk regular expression syntax
address@hidden @samp{awk} regular expression syntax
+
+
+The character @samp{.} matches any single character except the null character. 
 
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are invalid. 
 Within square brackets, @samp{\} can be used to quote the following character. 
 Character classes are not supported, so for example you would need to use 
@samp{[0-9]} instead of @samp{[[:digit:]]}.  
+
+GNU extensions are not supported and so @samp{\w}, @samp{\W}, @samp{\<}, 
@samp{\>}, @samp{\b}, @samp{\B}, @samp{\`}, and @samp{\'} match @samp{w}, 
@samp{W}, @samp{<}, @samp{>}, @samp{b}, @samp{B}, @samp{`}, and @samp{'} 
respectively.  
+
+Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} 
matches just itself.  A backslash followed by a digit matches that digit.  
+
+The alternation operator is @samp{|}.  
+
+The characters @samp{^} and @samp{$} always represent the beginning and end of 
a string respectively, except within square brackets.  Within brackets, 
@samp{^} can be used to invert the membership of the character class being 
specified.  
+
address@hidden, @samp{+} and @samp{?} are special at any point in a regular 
expression except:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After the alternation operator @samp{|}
+
address@hidden enumerate
+
+
+
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden egrep regular expression syntax
address@hidden @samp{egrep} regular expression syntax
+
+
+The character @samp{.} matches any single character except newline.  
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are ignored. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
supported; for example @samp{[[:digit:]]} will match a single decimal digit.  
Non-matching lists @address@hidden do not ever match newline.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with parentheses @samp{()}.  A backslash followed by a 
digit acts as a back-reference and matches the same thing as the previous 
grouped expression indicated by that number.  For example @samp{\2} matches the 
second group expression.  The order of group expressions is determined by the 
position of their opening parenthesis @samp{(}.  
+
+The alternation operator is @samp{|}.  
+
+The characters @samp{^} and @samp{$} always represent the beginning and end of 
a string respectively, except within square brackets.  Within brackets, 
@samp{^} can be used to invert the membership of the character class being 
specified.  
+
+The characters @samp{*}, @samp{+} and @samp{?} are special anywhere in a 
regular expression.  
+
+
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden ed regular expression syntax
address@hidden @samp{ed} regular expression syntax
+
+
+The character @samp{.} matches any single character except the null character. 
 
+
+
address@hidden @samp
+
address@hidden \+
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden \?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden + and ? 
+match themselves.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are invalid. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
supported; for example @samp{[[:digit:]]} will match a single decimal digit.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with backslashes followed by parentheses @samp{\(}, 
@samp{\)}.  A backslash followed by a digit acts as a back-reference and 
matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{\(}.  
+
+The alternation operator is @samp{\|}. 
+
+The character @samp{^} only represents the beginning of a string when it 
appears:
address@hidden
+
address@hidden 
+At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
+
address@hidden After the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
+The character @samp{$} only represents the end of a string when it appears:
address@hidden
+
address@hidden At the end of a regular expression
+
address@hidden Before an close-group, signified by 
address@hidden)}
address@hidden Before the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
address@hidden, @samp{\+} and @samp{\?} are special at any point in a regular 
expression except:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
+Intervals are specified by @address@hidden and @address@hidden  Invalid 
intervals such as @address@hidden are not accepted.  
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden emacs regular expression syntax
address@hidden @samp{emacs} regular expression syntax
+
+
+The character @samp{.} matches any single character except newline.  
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are ignored. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
not supported, so for example you would need to use @samp{[0-9]} instead of 
@samp{[[:digit:]]}.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with backslashes followed by parentheses @samp{\(}, 
@samp{\)}.  A backslash followed by a digit acts as a back-reference and 
matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{\(}.  
+
+The alternation operator is @samp{\|}. 
+
+The character @samp{^} only represents the beginning of a string when it 
appears:
address@hidden
+
address@hidden 
+At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
+
address@hidden After the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
+The character @samp{$} only represents the end of a string when it appears:
address@hidden
+
address@hidden At the end of a regular expression
+
address@hidden Before an close-group, signified by 
address@hidden)}
address@hidden Before the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
address@hidden, @samp{+} and @samp{?} are special at any point in a regular 
expression except:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
+
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden gnu-awk regular expression syntax
address@hidden @samp{gnu-awk} regular expression syntax
+
+
+The character @samp{.} matches any single character.  
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are invalid. 
 Within square brackets, @samp{\} can be used to quote the following character. 
 Character classes are supported; for example @samp{[[:digit:]]} will match a 
single decimal digit.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} 
matches just itself.  A backslash followed by a digit acts as a back-reference 
and matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{(}.  
+
+The alternation operator is @samp{|}.  
+
+The characters @samp{^} and @samp{$} always represent the beginning and end of 
a string respectively, except within square brackets.  Within brackets, 
@samp{^} can be used to invert the membership of the character class being 
specified.  
+
address@hidden, @samp{+} and @samp{?} are special at any point in a regular 
expression except:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After the alternation operator @samp{|}
+
address@hidden enumerate
+
+
+
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden grep regular expression syntax
address@hidden @samp{grep} regular expression syntax
+
+
+The character @samp{.} matches any single character except newline.  
+
+
address@hidden @samp
+
address@hidden \+
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden \?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden + and ? 
+match themselves.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are ignored. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
supported; for example @samp{[[:digit:]]} will match a single decimal digit.  
Non-matching lists @address@hidden do not ever match newline.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with backslashes followed by parentheses @samp{\(}, 
@samp{\)}.  A backslash followed by a digit acts as a back-reference and 
matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{\(}.  
+
+The alternation operator is @samp{\|}. 
+
+The character @samp{^} only represents the beginning of a string when it 
appears:
address@hidden
+
address@hidden 
+At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
+
address@hidden After a newline
+
address@hidden After the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
+The character @samp{$} only represents the end of a string when it appears:
address@hidden
+
address@hidden At the end of a regular expression
+
address@hidden Before an close-group, signified by 
address@hidden)}
address@hidden Before a newline
+
address@hidden Before the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
address@hidden, @samp{\+} and @samp{\?} are special at any point in a regular 
expression except:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After a newline
+
address@hidden After the alternation operator @samp{\|}
+
address@hidden enumerate
+
+
+Intervals are specified by @address@hidden and @address@hidden  Invalid 
intervals such as @address@hidden are not accepted.  
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden posix-awk regular expression syntax
address@hidden @samp{posix-awk} regular expression syntax
+
+
+The character @samp{.} matches any single character except the null character. 
 
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are invalid. 
 Within square brackets, @samp{\} can be used to quote the following character. 
 Character classes are supported; for example @samp{[[:digit:]]} will match a 
single decimal digit.  
+
+GNU extensions are not supported and so @samp{\w}, @samp{\W}, @samp{\<}, 
@samp{\>}, @samp{\b}, @samp{\B}, @samp{\`}, and @samp{\'} match @samp{w}, 
@samp{W}, @samp{<}, @samp{>}, @samp{b}, @samp{B}, @samp{`}, and @samp{'} 
respectively.  
+
+Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} 
matches just itself.  A backslash followed by a digit acts as a back-reference 
and matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{(}.  
+
+The alternation operator is @samp{|}.  
+
+The characters @samp{^} and @samp{$} always represent the beginning and end of 
a string respectively, except within square brackets.  Within brackets, 
@samp{^} can be used to invert the membership of the character class being 
specified.  
+
address@hidden, @samp{+} and @samp{?} are special at any point in a regular 
expression except the following places, where they are illegal:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After the alternation operator @samp{|}
+
address@hidden enumerate
+
+
+Intervals are specified by @address@hidden and @address@hidden  Invalid 
intervals such as @address@hidden are not accepted.  
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden posix-basic regular expression syntax
address@hidden @samp{posix-basic} regular expression syntax
+This is a synonym for ed.
address@hidden posix-egrep regular expression syntax
address@hidden @samp{posix-egrep} regular expression syntax
+
+
+The character @samp{.} matches any single character except newline.  
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are ignored. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
supported; for example @samp{[[:digit:]]} will match a single decimal digit.  
Non-matching lists @address@hidden do not ever match newline.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with parentheses @samp{()}.  A backslash followed by a 
digit acts as a back-reference and matches the same thing as the previous 
grouped expression indicated by that number.  For example @samp{\2} matches the 
second group expression.  The order of group expressions is determined by the 
position of their opening parenthesis @samp{(}.  
+
+The alternation operator is @samp{|}.  
+
+The characters @samp{^} and @samp{$} always represent the beginning and end of 
a string respectively, except within square brackets.  Within brackets, 
@samp{^} can be used to invert the membership of the character class being 
specified.  
+
+The characters @samp{*}, @samp{+} and @samp{?} are special anywhere in a 
regular expression.  
+
+Intervals are specified by @address@hidden and @address@hidden  Invalid 
intervals are treated as literals, for example @address@hidden is treated as 
@address@hidden
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden posix-extended regular expression syntax
address@hidden @samp{posix-extended} regular expression syntax
+
+
+The character @samp{.} matches any single character except the null character. 
 
+
+
address@hidden @samp
+
address@hidden +
+indicates that the regular expression should match one or more occurrences of 
the previous atom or regexp.  
address@hidden ?
+indicates that the regular expression should match zero or one occurrence of 
the previous atom or regexp.  
address@hidden \+
+matches a @samp{+}
address@hidden \?
+matches a @samp{?}.  
address@hidden table
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are invalid. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
supported; for example @samp{[[:digit:]]} will match a single decimal digit.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} 
matches just itself.  A backslash followed by a digit acts as a back-reference 
and matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{(}.  
+
+The alternation operator is @samp{|}.  
+
+The characters @samp{^} and @samp{$} always represent the beginning and end of 
a string respectively, except within square brackets.  Within brackets, 
@samp{^} can be used to invert the membership of the character class being 
specified.  
+
address@hidden, @samp{+} and @samp{?} are special at any point in a regular 
expression except the following places, where they are illegal:
address@hidden
+
address@hidden At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
address@hidden After the alternation operator @samp{|}
+
address@hidden enumerate
+
+
+Intervals are specified by @address@hidden and @address@hidden  Invalid 
intervals such as @address@hidden are not accepted.  
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden posix-minimal-basic regular expression syntax
address@hidden @samp{posix-minimal-basic} regular expression syntax
+
+
+The character @samp{.} matches any single character except the null character. 
 
+
+
+
+Bracket expressions are used to match ranges of characters.  Bracket 
expressions where the range is backward, for example @samp{[z-a]}, are invalid. 
 Within square brackets, @samp{\} is taken literally.  Character classes are 
supported; for example @samp{[[:digit:]]} will match a single decimal digit.  
+
+GNU extensions are supported:
address@hidden
+
address@hidden @samp{\w} matches a character within a word
+
address@hidden @samp{\W} matches a character which is not within a word
+
address@hidden @samp{\<} matches the beginning of a word
+
address@hidden @samp{\>} matches the end of a word
+
address@hidden @samp{\b} matches a word boundary
+
address@hidden @samp{\B} matches characters which are not a word boundary
+
address@hidden @samp{\`} matches the beginning of the whole input
+
address@hidden @samp{\'} matches the end of the whole input
+
address@hidden enumerate
+
+
+Grouping is performed with backslashes followed by parentheses @samp{\(}, 
@samp{\)}.  A backslash followed by a digit acts as a back-reference and 
matches the same thing as the previous grouped expression indicated by that 
number.  For example @samp{\2} matches the second group expression.  The order 
of group expressions is determined by the position of their opening parenthesis 
@samp{\(}.  
+
+
+
+The character @samp{^} only represents the beginning of a string when it 
appears:
address@hidden
+
address@hidden 
+At the beginning of a regular expression
+
address@hidden After an open-group, signified by 
address@hidden(}
+
address@hidden enumerate
+
+
+The character @samp{$} only represents the end of a string when it appears:
address@hidden
+
address@hidden At the end of a regular expression
+
address@hidden Before an close-group, signified by 
address@hidden)}
address@hidden enumerate
+
+
+
+
+Intervals are specified by @address@hidden and @address@hidden  Invalid 
intervals such as @address@hidden are not accepted.  
+
+The longest possible match is returned; this applies to the regular expression 
as a whole and (subject to this constraint) to subexpressions within groups.  
+
+
address@hidden sed regular expression syntax
address@hidden @samp{sed} regular expression syntax
+This is a synonym for ed.
\ No newline at end of file