[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH] Editorial corrections to regexprop-generic.texi.
From: |
James Youngman |
Subject: |
[PATCH] Editorial corrections to regexprop-generic.texi. |
Date: |
Mon, 3 Dec 2007 11:31:47 +0000 |
2007-11-27 James Youngman <address@hidden>
* doc/regexprops-generic.texi: change "an close-group" to "a
close-group" and "illegal" to "not allowed".
---
doc/regexprops-generic.texi | 236 ++++++++++++++++++++++---------------------
1 files changed, 119 insertions(+), 117 deletions(-)
diff --git a/doc/regexprops-generic.texi b/doc/regexprops-generic.texi
index 269bd45..19bfca6 100644
--- a/doc/regexprops-generic.texi
+++ b/doc/regexprops-generic.texi
@@ -1,6 +1,6 @@
address@hidden Copyright (C) 1994, 1996, 1998, 2000, 2001, 2003, 2004, 2005,
2006
address@hidden Copyright (C) 1994, 1996, 1998, 2000, 2001, 2003, 2004, 2005,
2006, 2007
@c Free Software Foundation, Inc.
-
address@hidden
@c Permission is granted to copy, distribute and/or modify this document
@c under the terms of the GNU Free Documentation License, Version 1.2 or
@c any later version published by the Free Software Foundation; with no
@@ -8,6 +8,8 @@
@c Texts. A copy of the license is included in the ``GNU Free
@c Documentation License'' file as part of this distribution.
address@hidden this regular expression description is for: generic
+
@menu
* awk regular expression syntax::
* egrep regular expression syntax::
@@ -27,38 +29,38 @@
@subsection @samp{awk} regular expression syntax
-The character @samp{.} matches any single character except the null character.
+The character @samp{.} matches any single character except the null character.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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:]]}.
+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.
+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.
+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 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{^} 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.
@samp{*}, @samp{+} and @samp{?} are special at any point in a regular
expression except:
@enumerate
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{(}
@item After the alternation operator @samp{|}
@@ -67,30 +69,30 @@ The characters @samp{^} and @samp{$} always represent the
beginning and end of a
-The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node egrep regular expression syntax
@subsection @samp{egrep} regular expression syntax
-The character @samp{.} matches any single character except newline.
+The character @samp{.} matches any single character except newline.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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.
+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:
@enumerate
@@ -114,38 +116,38 @@ GNU extensions are supported:
@end 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{(}.
+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 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{^} 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 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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node ed regular expression syntax
@subsection @samp{ed} regular expression syntax
-The character @samp{.} matches any single character except the null character.
+The character @samp{.} matches any single character except the null character.
@table @samp
@item \+
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item \?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
address@hidden + and ?
-match themselves.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
address@hidden + and ?
+match themselves.
@end 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.
+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:
@enumerate
@@ -169,17 +171,17 @@ GNU extensions are supported:
@end 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{\(}.
+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 alternation operator is @samp{\|}.
The character @samp{^} only represents the beginning of a string when it
appears:
@enumerate
address@hidden
address@hidden
At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@item After the alternation operator @samp{\|}
@@ -192,7 +194,7 @@ The character @samp{$} only represents the end of a string
when it appears:
@item At the end of a regular expression
address@hidden Before an close-group, signified by
address@hidden Before a close-group, signified by
@samp{\)}
@item Before the alternation operator @samp{\|}
@@ -204,39 +206,39 @@ The character @samp{$} only represents the end of a
string when it appears:
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@item After the alternation operator @samp{\|}
@end enumerate
-Intervals are specified by @address@hidden and @address@hidden Invalid
intervals such as @address@hidden are not accepted.
+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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node emacs regular expression syntax
@subsection @samp{emacs} regular expression syntax
-The character @samp{.} matches any single character except newline.
+The character @samp{.} matches any single character except newline.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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:]]}.
+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:
@enumerate
@@ -260,17 +262,17 @@ GNU extensions are supported:
@end 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{\(}.
+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 alternation operator is @samp{\|}.
The character @samp{^} only represents the beginning of a string when it
appears:
@enumerate
address@hidden
address@hidden
At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@item After the alternation operator @samp{\|}
@@ -283,7 +285,7 @@ The character @samp{$} only represents the end of a string
when it appears:
@item At the end of a regular expression
address@hidden Before an close-group, signified by
address@hidden Before a close-group, signified by
@samp{\)}
@item Before the alternation operator @samp{\|}
@@ -295,7 +297,7 @@ The character @samp{$} only represents the end of a string
when it appears:
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@item After the alternation operator @samp{\|}
@@ -304,30 +306,30 @@ The character @samp{$} only represents the end of a
string when it appears:
-The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node gnu-awk regular expression syntax
@subsection @samp{gnu-awk} regular expression syntax
-The character @samp{.} matches any single character.
+The character @samp{.} matches any single character.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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.
+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:
@enumerate
@@ -351,18 +353,18 @@ GNU extensions are supported:
@end 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{(}.
+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 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{^} 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.
@samp{*}, @samp{+} and @samp{?} are special at any point in a regular
expression except:
@enumerate
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{(}
@item After the alternation operator @samp{|}
@@ -371,28 +373,28 @@ The characters @samp{^} and @samp{$} always represent the
beginning and end of a
-The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node grep regular expression syntax
@subsection @samp{grep} regular expression syntax
-The character @samp{.} matches any single character except newline.
+The character @samp{.} matches any single character except newline.
@table @samp
@item \+
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item \?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
address@hidden + and ?
-match themselves.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
address@hidden + and ?
+match themselves.
@end 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.
+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:
@enumerate
@@ -416,17 +418,17 @@ GNU extensions are supported:
@end 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{\(}.
+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 alternation operator is @samp{\|}.
The character @samp{^} only represents the beginning of a string when it
appears:
@enumerate
address@hidden
address@hidden
At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@item After a newline
@@ -441,7 +443,7 @@ The character @samp{$} only represents the end of a string
when it appears:
@item At the end of a regular expression
address@hidden Before an close-group, signified by
address@hidden Before a close-group, signified by
@samp{\)}
@item Before a newline
@@ -455,7 +457,7 @@ The character @samp{$} only represents the end of a string
when it appears:
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@item After a newline
@@ -464,56 +466,56 @@ The character @samp{$} only represents the end of a
string when it appears:
@end enumerate
-Intervals are specified by @address@hidden and @address@hidden Invalid
intervals such as @address@hidden are not accepted.
+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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node posix-awk regular expression syntax
@subsection @samp{posix-awk} regular expression syntax
-The character @samp{.} matches any single character except the null character.
+The character @samp{.} matches any single character except the null character.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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.
+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.
+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{(}.
+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 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{^} 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, @samp{+} and @samp{?} are special at any point in a regular
expression except the following places, where they are not allowed:
@enumerate
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{(}
@item After the alternation operator @samp{|}
@end enumerate
-Intervals are specified by @address@hidden and @address@hidden Invalid
intervals such as @address@hidden are not accepted.
+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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node posix-basic regular expression syntax
@@ -523,23 +525,23 @@ This is a synonym for ed.
@subsection @samp{posix-egrep} regular expression syntax
-The character @samp{.} matches any single character except newline.
+The character @samp{.} matches any single character except newline.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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.
+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:
@enumerate
@@ -563,40 +565,40 @@ GNU extensions are supported:
@end 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{(}.
+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 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{^} 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 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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node posix-extended regular expression syntax
@subsection @samp{posix-extended} regular expression syntax
-The character @samp{.} matches any single character except the null character.
+The character @samp{.} matches any single character except the null character.
@table @samp
@item +
-indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
+indicates that the regular expression should match one or more occurrences of
the previous atom or regexp.
@item ?
-indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
+indicates that the regular expression should match zero or one occurrence of
the previous atom or regexp.
@item \+
matches a @samp{+}
@item \?
-matches a @samp{?}.
+matches a @samp{?}.
@end 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.
+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:
@enumerate
@@ -620,38 +622,38 @@ GNU extensions are supported:
@end 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{(}.
+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 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{^} 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, @samp{+} and @samp{?} are special at any point in a regular
expression except the following places, where they are not allowed:
@enumerate
@item At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{(}
@item After the alternation operator @samp{|}
@end enumerate
-Intervals are specified by @address@hidden and @address@hidden Invalid
intervals such as @address@hidden are not accepted.
+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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node posix-minimal-basic regular expression syntax
@subsection @samp{posix-minimal-basic} regular expression syntax
-The character @samp{.} matches any single character except the null character.
+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.
+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:
@enumerate
@@ -675,17 +677,17 @@ GNU extensions are supported:
@end 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{\(}.
+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:
@enumerate
address@hidden
address@hidden
At the beginning of a regular expression
address@hidden After an open-group, signified by
address@hidden After an open-group, signified by
@samp{\(}
@end enumerate
@@ -696,18 +698,18 @@ The character @samp{$} only represents the end of a
string when it appears:
@item At the end of a regular expression
address@hidden Before an close-group, signified by
address@hidden Before a close-group, signified by
@samp{\)}
@end enumerate
-Intervals are specified by @address@hidden and @address@hidden Invalid
intervals such as @address@hidden are not accepted.
+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.
+The longest possible match is returned; this applies to the regular expression
as a whole and (subject to this constraint) to subexpressions within groups.
@node sed regular expression syntax
@subsection @samp{sed} regular expression syntax
-This is a synonym for ed.
+This is a synonym for ed.
\ No newline at end of file
--
1.5.3.6