From 07dcdcf7743b1664cb49ee7f0922f314f011a3af Mon Sep 17 00:00:00 2001 From: James Youngman Date: Mon, 3 Dec 2007 09:53:02 -0800 Subject: [PATCH] * doc/regexprops-generic.texi: change "an close-group" to "a close-group" and "illegal" to "not allowed". --- ChangeLog | 5 + doc/regexprops-generic.texi | 236 ++++++++++++++++++++++---------------------- 2 files changed, 124 insertions(+), 117 deletions(-) diff --git a/ChangeLog b/ChangeLog index a9fbb7839..d9d80e9a4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2007-12-03 James Youngman + + * doc/regexprops-generic.texi: change "an close-group" to "a + close-group" and "illegal" to "not allowed". + 2007-11-23 Ralf Wildenhues * lib/unictype/pr_byname.c: Include unictype/pr_byname.h instead of diff --git a/doc/regexprops-generic.texi b/doc/regexprops-generic.texi index 269bd45b4..19bfca68f 100644 --- a/doc/regexprops-generic.texi +++ b/doc/regexprops-generic.texi @@ -1,6 +1,6 @@ -@c Copyright (C) 1994, 1996, 1998, 2000, 2001, 2003, 2004, 2005, 2006 +@c Copyright (C) 1994, 1996, 1998, 2000, 2001, 2003, 2004, 2005, 2006, 2007 @c Free Software Foundation, Inc. - +@c @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. +@c 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 -@item After an open-group, signified by +@item 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 @samp{[^@dots{}]} 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 @samp{[^@dots{}]} 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. -@item + and ? -match themselves. +indicates that the regular expression should match zero or one occurrence of the previous atom or regexp. +@item + 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 -@item +@item At the beginning of a regular expression -@item After an open-group, signified by +@item 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 -@item Before an close-group, signified by +@item 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 -@item After an open-group, signified by +@item After an open-group, signified by @samp{\(} @item After the alternation operator @samp{\|} @end enumerate -Intervals are specified by @samp{\@{} and @samp{\@}}. Invalid intervals such as @samp{a\@{1z} are not accepted. +Intervals are specified by @samp{\@{} and @samp{\@}}. Invalid intervals such as @samp{a\@{1z} 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 -@item +@item At the beginning of a regular expression -@item After an open-group, signified by +@item 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 -@item Before an close-group, signified by +@item 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 -@item After an open-group, signified by +@item 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 -@item After an open-group, signified by +@item 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. -@item + and ? -match themselves. +indicates that the regular expression should match zero or one occurrence of the previous atom or regexp. +@item + 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 @samp{[^@dots{}]} 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 @samp{[^@dots{}]} 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 -@item +@item At the beginning of a regular expression -@item After an open-group, signified by +@item 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 -@item Before an close-group, signified by +@item 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 -@item After an open-group, signified by +@item 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 @samp{\@{} and @samp{\@}}. Invalid intervals such as @samp{a\@{1z} are not accepted. +Intervals are specified by @samp{\@{} and @samp{\@}}. Invalid intervals such as @samp{a\@{1z} 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. -@samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except the following places, where they are illegal: +@samp{*}, @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 -@item After an open-group, signified by +@item After an open-group, signified by @samp{(} @item After the alternation operator @samp{|} @end enumerate -Intervals are specified by @samp{@{} and @samp{@}}. Invalid intervals such as @samp{a@{1z} are not accepted. +Intervals are specified by @samp{@{} and @samp{@}}. Invalid intervals such as @samp{a@{1z} 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 @samp{[^@dots{}]} 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 @samp{[^@dots{}]} 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 @samp{@{} and @samp{@}}. Invalid intervals are treated as literals, for example @samp{a@{1} is treated as @samp{a\@{1} -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. -@samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except the following places, where they are illegal: +@samp{*}, @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 -@item After an open-group, signified by +@item After an open-group, signified by @samp{(} @item After the alternation operator @samp{|} @end enumerate -Intervals are specified by @samp{@{} and @samp{@}}. Invalid intervals such as @samp{a@{1z} are not accepted. +Intervals are specified by @samp{@{} and @samp{@}}. Invalid intervals such as @samp{a@{1z} 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 -@item +@item At the beginning of a regular expression -@item After an open-group, signified by +@item 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 -@item Before an close-group, signified by +@item Before a close-group, signified by @samp{\)} @end enumerate -Intervals are specified by @samp{\@{} and @samp{\@}}. Invalid intervals such as @samp{a\@{1z} are not accepted. +Intervals are specified by @samp{\@{} and @samp{\@}}. Invalid intervals such as @samp{a\@{1z} 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 -- 2.11.0