Markup nits.
diff --git a/Doc/lib/libre.tex b/Doc/lib/libre.tex
index 8f41e1a..45844e4 100644
--- a/Doc/lib/libre.tex
+++ b/Doc/lib/libre.tex
@@ -33,8 +33,7 @@
Usually patterns will be expressed in Python code using this raw
string notation.
-\subsection{Regular Expression Syntax}
-\label{re-syntax}
+\subsection{Regular Expression Syntax \label{re-syntax}}
A regular expression (or RE) specifies a set of strings that matches
it; the functions in this module let you check if a particular string
@@ -70,29 +69,31 @@
% define these since they're used twice:
\newcommand{\MyLeftMargin}{0.7in}
\newcommand{\MyLabelWidth}{0.65in}
+
\begin{list}{}{\leftmargin \MyLeftMargin \labelwidth \MyLabelWidth}
+
\item[\character{.}] (Dot.) In the default mode, this matches any
character except a newline. If the \constant{DOTALL} flag has been
specified, this matches any character including a newline.
-%
+
\item[\character{\^}] (Caret.) Matches the start of the string, and in
\constant{MULTILINE} mode also matches immediately after each newline.
-%
+
\item[\character{\$}] Matches the end of the string, and in
\constant{MULTILINE} mode also matches before a newline.
\regexp{foo} matches both 'foo' and 'foobar', while the regular
expression \regexp{foo\$} matches only 'foo'.
-%
+
\item[\character{*}] Causes the resulting RE to
match 0 or more repetitions of the preceding RE, as many repetitions
as are possible. \regexp{ab*} will
match 'a', 'ab', or 'a' followed by any number of 'b's.
-%
+
\item[\character{+}] Causes the
resulting RE to match 1 or more repetitions of the preceding RE.
\regexp{ab+} will match 'a' followed by any non-zero number of 'b's; it
will not match just 'a'.
-%
+
\item[\character{?}] Causes the resulting RE to
match 0 or 1 repetitions of the preceding RE. \regexp{ab?} will
match either 'a' or 'ab'.
@@ -105,24 +106,26 @@
\dfn{non-greedy} or \dfn{minimal} fashion; as \emph{few} characters as
possible will be matched. Using \regexp{.*?} in the previous
expression will match only \code{'<H1>'}.
-%
+
\item[\code{\{\var{m},\var{n}\}}] Causes the resulting RE to match from
\var{m} to \var{n} repetitions of the preceding RE, attempting to
match as many repetitions as possible. For example, \regexp{a\{3,5\}}
will match from 3 to 5 \character{a} characters. Omitting \var{m} is the same
as specifying 0 for the lower bound; omitting \var{n} specifies an
infinite upper bound.
-%
+
\item[\code{\{\var{m},\var{n}\}?}] Causes the resulting RE to
match from \var{m} to \var{n} repetitions of the preceding RE,
attempting to match as \emph{few} repetitions as possible. This is
the non-greedy version of the previous qualifier. For example, on the
-6-character string \code{'aaaaaa'}, \regexp{a\{3,5\}} will match 5 \character{a}
-characters, while \regexp{a\{3,5\}?} will only match 3 characters.
-%
-\item[\character{\e}] Either escapes special characters (permitting you to match
-characters like \character{*}, \character{?}, and so forth), or
-signals a special sequence; special sequences are discussed below.
+6-character string \code{'aaaaaa'}, \regexp{a\{3,5\}} will match 5
+\character{a} characters, while \regexp{a\{3,5\}?} will only match 3
+characters.
+
+\item[\character{\e}] Either escapes special characters (permitting
+you to match characters like \character{*}, \character{?}, and so
+forth), or signals a special sequence; special sequences are discussed
+below.
If you're not using a raw string to
express the pattern, remember that Python also uses the
@@ -133,7 +136,7 @@
be repeated twice. This is complicated and hard to understand, so
it's highly recommended that you use raw strings for all but the
simplest expressions.
-%
+
\item[\code{[]}] Used to indicate a set of characters. Characters can
be listed individually, or a range of characters can be indicated by
giving two characters and separating them by a \character{-}. Special
@@ -153,28 +156,27 @@
simply match the \character{\^} character. For example, \regexp{[\^5]}
will match any character except \character{5}.
-%
\item[\character{|}]\code{A|B}, where A and B can be arbitrary REs,
creates a regular expression that will match either A or B. This can
be used inside groups (see below) as well. To match a literal \character{|},
use \regexp{\e|}, or enclose it inside a character class, as in \regexp{[|]}.
-%
+
\item[\code{(...)}] Matches whatever regular expression is inside the
parentheses, and indicates the start and end of a group; the contents
of a group can be retrieved after a match has been performed, and can
be matched later in the string with the \regexp{\e \var{number}} special
-sequence, described below. To match the literals \character{(} or \character{')},
-use \regexp{\e(} or \regexp{\e)}, or enclose them inside a character
-class: \regexp{[(] [)]}.
-%
-\item[\code{(?...)}] This is an extension notation (a \character{?} following a
-\character{(} is not meaningful otherwise). The first character after
-the \character{?}
+sequence, described below. To match the literals \character{(} or
+\character{')}, use \regexp{\e(} or \regexp{\e)}, or enclose them
+inside a character class: \regexp{[(] [)]}.
+
+\item[\code{(?...)}] This is an extension notation (a \character{?}
+following a \character{(} is not meaningful otherwise). The first
+character after the \character{?}
determines what the meaning and further syntax of the construct is.
Extensions usually do not create a new group;
\regexp{(?P<\var{name}>...)} is the only exception to this rule.
Following are the currently supported extensions.
-%
+
\item[\code{(?iLmsx)}] (One or more letters from the set \character{i},
\character{L}, \character{m}, \character{s}, \character{x}.) The group matches
the empty string; the letters set the corresponding flags
@@ -182,13 +184,13 @@
\constant{re.X}) for the entire regular expression. This is useful if
you wish to include the flags as part of the regular expression, instead
of passing a \var{flag} argument to the \function{compile()} function.
-%
+
\item[\code{(?:...)}] A non-grouping version of regular parentheses.
Matches whatever regular expression is inside the parentheses, but the
substring matched by the
group \emph{cannot} be retrieved after performing a match or
referenced later in the pattern.
-%
+
\item[\code{(?P<\var{name}>...)}] Similar to regular parentheses, but
the substring matched by the group is accessible via the symbolic group
name \var{name}. Group names must be valid Python identifiers. A
@@ -201,18 +203,18 @@
name in arguments to methods of match objects, such as \code{m.group('id')}
or \code{m.end('id')}, and also by name in pattern text
(e.g. \regexp{(?P=id)}) and replacement text (e.g. \code{\e g<id>}).
-%
+
\item[\code{(?P=\var{name})}] Matches whatever text was matched by the
earlier group named \var{name}.
-%
+
\item[\code{(?\#...)}] A comment; the contents of the parentheses are
simply ignored.
-%
+
\item[\code{(?=...)}] Matches if \regexp{...} matches next, but doesn't
consume any of the string. This is called a lookahead assertion. For
example, \regexp{Isaac (?=Asimov)} will match \code{'Isaac~'} only if it's
followed by \code{'Asimov'}.
-%
+
\item[\code{(?!...)}] Matches if \regexp{...} doesn't match next. This
is a negative lookahead assertion. For example,
\regexp{Isaac (?!Asimov)} will match \code{'Isaac~'} only if it's \emph{not}
@@ -474,8 +476,7 @@
\end{excdesc}
-\subsection{Regular Expression Objects}
-\label{re-objects}
+\subsection{Regular Expression Objects \label{re-objects}}
Compiled regular expression objects support the following methods and
attributes:
@@ -547,8 +548,7 @@
\end{memberdesc}
-\subsection{Match Objects}
-\label{match-objects}
+\subsection{Match Objects \label{match-objects}}
\class{MatchObject} instances support the following methods and attributes: