@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
-@c Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2002, 2003,
+@c 2004, 2005, 2006 Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/searching
@node Searching and Matching, Syntax Tables, Non-ASCII Characters, Top
@menu
* String Search:: Search for an exact match.
+* Searching and Case:: Case-independent or case-significant searching.
* Regular Expressions:: Describing classes of strings.
* Regexp Search:: Searching for a match for a regexp.
* POSIX Regexps:: Searching POSIX-style for the longest match.
-* Search and Replace:: Internals of @code{query-replace}.
-* Match Data:: Finding out which part of the text matched
- various parts of a regexp, after regexp search.
-* Searching and Case:: Case-independent or case-significant searching.
+* Match Data:: Finding out which part of the text matched,
+ after a string or regexp search.
+* Search and Replace:: Commands that loop, searching and replacing.
* Standard Regexps:: Useful regexps for finding sentences, pages,...
@end menu
return the new position of point in that case, but some existing
programs may depend on a value of @code{nil}.)
+The argument @var{noerror} only affects valid searches which fail to
+find a match. Invalid arguments cause errors regardless of
+@var{noerror}.
+
If @var{repeat} is supplied (it must be a positive number), then the
search is repeated that many times (each time starting at the end of the
previous time's match). If these successive searches succeed, the
function succeeds, moving point and returning its new value. Otherwise
-the search fails.
+the search fails, with results depending on the value of
+@var{noerror}, as described above.
@end deffn
@deffn Command search-backward string &optional limit noerror repeat
@end group
@end example
-If @var{limit} is non-@code{nil} (it must be a position in the current
-buffer), then it is the upper bound to the search. The match found must
-not extend after that position.
+If @var{limit} is non-@code{nil}, it must be a position in the current
+buffer; it specifies the upper bound to the search. The match found
+must not extend after that position.
If @var{noerror} is @code{nil}, then @code{word-search-forward} signals
an error if the search fails. If @var{noerror} is @code{t}, then it
returns @code{nil} instead of signaling an error. If @var{noerror} is
neither @code{nil} nor @code{t}, it moves point to @var{limit} (or the
-end of the buffer) and returns @code{nil}.
+end of the accessible portion of the buffer) and returns @code{nil}.
If @var{repeat} is non-@code{nil}, then the search is repeated that many
times. Point is positioned at the end of the last match.
beginning of the match.
@end deffn
+@node Searching and Case
+@section Searching and Case
+@cindex searching and case
+
+ By default, searches in Emacs ignore the case of the text they are
+searching through; if you specify searching for @samp{FOO}, then
+@samp{Foo} or @samp{foo} is also considered a match. This applies to
+regular expressions, too; thus, @samp{[aB]} would match @samp{a} or
+@samp{A} or @samp{b} or @samp{B}.
+
+ If you do not want this feature, set the variable
+@code{case-fold-search} to @code{nil}. Then all letters must match
+exactly, including case. This is a buffer-local variable; altering the
+variable affects only the current buffer. (@xref{Intro to
+Buffer-Local}.) Alternatively, you may change the value of
+@code{default-case-fold-search}, which is the default value of
+@code{case-fold-search} for buffers that do not override it.
+
+ Note that the user-level incremental search feature handles case
+distinctions differently. When given a lower case letter, it looks for
+a match of either case, but when given an upper case letter, it looks
+for an upper case letter only. But this has nothing to do with the
+searching functions used in Lisp code.
+
+@defopt case-replace
+This variable determines whether the higher level replacement
+functions should preserve case. If the variable is @code{nil}, that
+means to use the replacement text verbatim. A non-@code{nil} value
+means to convert the case of the replacement text according to the
+text being replaced.
+
+This variable is used by passing it as an argument to the function
+@code{replace-match}. @xref{Replacing Match}.
+@end defopt
+
+@defopt case-fold-search
+This buffer-local variable determines whether searches should ignore
+case. If the variable is @code{nil} they do not ignore case; otherwise
+they do ignore case.
+@end defopt
+
+@defvar default-case-fold-search
+The value of this variable is the default value for
+@code{case-fold-search} in buffers that do not override it. This is the
+same as @code{(default-value 'case-fold-search)}.
+@end defvar
+
@node Regular Expressions
@section Regular Expressions
@cindex regular expression
a regexp is a very powerful operation. This section explains how to write
regexps; the following section says how to search for them.
+@findex re-builder
+@cindex authoring regular expressions
+ For convenient interactive development of regular expressions, you
+can use the @kbd{M-x re-builder} command. It provides a convenient
+interface for creating regular expressions, by giving immediate visual
+feedback in a separate buffer. As you edit the regexp, all its
+matches in the target buffer are highlighted. Each parenthesized
+sub-expression of the regexp is shown in a distinct face, which makes
+it easier to verify even very complex regexps.
+
@menu
* Syntax of Regexps:: Rules for writing regular expressions.
-* Regexp Functions:: Functions for operating on regular expressions.
* Regexp Example:: Illustrates regular expression syntax.
+* Regexp Functions:: Functions for operating on regular expressions.
@end menu
@node Syntax of Regexps
Regular expressions have a syntax in which a few characters are
special constructs and the rest are @dfn{ordinary}. An ordinary
-character is a simple regular expression that matches that character and
-nothing else. The special characters are @samp{.}, @samp{*}, @samp{+},
-@samp{?}, @samp{[}, @samp{]}, @samp{^}, @samp{$}, and @samp{\}; no new
-special characters will be defined in the future. Any other character
-appearing in a regular expression is ordinary, unless a @samp{\}
-precedes it.
+character is a simple regular expression that matches that character
+and nothing else. The special characters are @samp{.}, @samp{*},
+@samp{+}, @samp{?}, @samp{[}, @samp{^}, @samp{$}, and @samp{\}; no new
+special characters will be defined in the future. The character
+@samp{]} is special if it ends a character alternative (see later).
+The character @samp{-} is special inside a character alternative. A
+@samp{[:} and balancing @samp{:]} enclose a character class inside a
+character alternative. Any other character appearing in a regular
+expression is ordinary, unless a @samp{\} precedes it.
For example, @samp{f} is not a special character, so it is ordinary, and
therefore @samp{f} is a regular expression that matches the string
The next alternative is for @samp{a*} to match only two @samp{a}s. With
this choice, the rest of the regexp matches successfully.@refill
-Nested repetition operators can be extremely slow if they specify
-backtracking loops. For example, it could take hours for the regular
-expression @samp{\(x+y*\)*a} to try to match the sequence
-@samp{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz}, before it ultimately fails.
-The slowness is because Emacs must try each imaginable way of grouping
-the 35 @samp{x}s before concluding that none of them can work. To make
-sure your regular expressions run fast, check nested repetitions
-carefully.
+Nested repetition operators take a long time, or even forever, if they
+lead to ambiguous matching. For example, trying to match the regular
+expression @samp{\(x+y*\)*a} against the string
+@samp{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz} could take hours before it
+ultimately fails. Emacs must try each way of grouping the 35
+@samp{x}s before concluding that none of them can work. Even worse,
+@samp{\(x*\)*} can match the null string in infinitely many ways, so
+it causes an infinite loop. To avoid these problems, check nested
+repetitions carefully.
@item @samp{+}
@cindex @samp{+} in regexp
You can also include character ranges in a character alternative, by
writing the starting and ending characters with a @samp{-} between them.
-Thus, @samp{[a-z]} matches any lower-case @sc{ascii} letter. Ranges may be
-intermixed freely with individual characters, as in @samp{[a-z$%.]},
-which matches any lower case @sc{ascii} letter or @samp{$}, @samp{%} or
-period.
+Thus, @samp{[a-z]} matches any lower-case @acronym{ASCII} letter.
+Ranges may be intermixed freely with individual characters, as in
+@samp{[a-z$%.]}, which matches any lower case @acronym{ASCII} letter
+or @samp{$}, @samp{%} or period.
Note that the usual regexp special characters are not special inside a
character alternative. A completely different set of characters is
To include @samp{^} in a character alternative, put it anywhere but at
the beginning.
-The beginning and end of a range must be in the same character set
-(@pxref{Character Sets}). Thus, @samp{[a-\x8e0]} is invalid because
-@samp{a} is in the @sc{ascii} character set but the character 0x8e0
-(@samp{a} with grave accent) is in the Emacs character set for Latin-1.
-
-You cannot always match all non-@sc{ascii} characters with the regular
-expression @samp{[\200-\377]}. This works when searching a unibyte
+The beginning and end of a range of multibyte characters must be in
+the same character set (@pxref{Character Sets}). Thus,
+@code{"[\x8e0-\x97c]"} is invalid because character 0x8e0 (@samp{a}
+with grave accent) is in the Emacs character set for Latin-1 but the
+character 0x97c (@samp{u} with diaeresis) is in the Emacs character
+set for Latin-2. (We use Lisp string syntax to write that example,
+and a few others in the next few paragraphs, in order to include hex
+escape sequences in them.)
+
+If a range starts with a unibyte character @var{c} and ends with a
+multibyte character @var{c2}, the range is divided into two parts: one
+is @samp{@var{c}..?\377}, the other is @samp{@var{c1}..@var{c2}}, where
+@var{c1} is the first character of the charset to which @var{c2}
+belongs.
+
+You cannot always match all non-@acronym{ASCII} characters with the regular
+expression @code{"[\200-\377]"}. This works when searching a unibyte
buffer or string (@pxref{Text Representations}), but not in a multibyte
-buffer or string, because many non-@sc{ascii} characters have codes
-above octal 0377. However, the regular expression @samp{[^\000-\177]}
-does match all non-@sc{ascii} characters (see below regarding @samp{^}),
+buffer or string, because many non-@acronym{ASCII} characters have codes
+above octal 0377. However, the regular expression @code{"[^\000-\177]"}
+does match all non-@acronym{ASCII} characters (see below regarding @samp{^}),
in both multibyte and unibyte representations, because only the
-@sc{ascii} characters are excluded.
+@acronym{ASCII} characters are excluded.
-Starting in Emacs 21, a character alternative can also specify named
+A character alternative can also specify named
character classes (@pxref{Char Classes}). This is a POSIX feature whose
syntax is @samp{[:@var{class}:]}. Using a character class is equivalent
to mentioning each of the characters in that class; but the latter is
@item @samp{[^ @dots{} ]}
@cindex @samp{^} in regexp
-@samp{[^} begins a @dfn{complemented character alternative}, which matches any
-character except the ones specified. Thus, @samp{[^a-z0-9A-Z]} matches
-all characters @emph{except} letters and digits.
+@samp{[^} begins a @dfn{complemented character alternative}. This
+matches any character except the ones specified. Thus,
+@samp{[^a-z0-9A-Z]} matches all characters @emph{except} letters and
+digits.
@samp{^} is not special in a character alternative unless it is the first
character. The character following the @samp{^} is treated as if it
@item @samp{^}
@cindex beginning of line in regexp
-is a special character that matches the empty string, but only at the
-beginning of a line in the text being matched. Otherwise it fails to
-match anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at
-the beginning of a line.
+When matching a buffer, @samp{^} matches the empty string, but only at the
+beginning of a line in the text being matched (or the beginning of the
+accessible portion of the buffer). Otherwise it fails to match
+anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at the
+beginning of a line.
When matching a string instead of a buffer, @samp{^} matches at the
-beginning of the string or after a newline character @samp{\n}.
+beginning of the string or after a newline character.
For historical compatibility reasons, @samp{^} can be used only at the
beginning of the regular expression, or after @samp{\(} or @samp{\|}.
@item @samp{$}
@cindex @samp{$} in regexp
@cindex end of line in regexp
-is similar to @samp{^} but matches only at the end of a line. Thus,
-@samp{x+$} matches a string of one @samp{x} or more at the end of a line.
+is similar to @samp{^} but matches only at the end of a line (or the
+end of the accessible portion of the buffer). Thus, @samp{x+$}
+matches a string of one @samp{x} or more at the end of a line.
When matching a string instead of a buffer, @samp{$} matches at the end
-of the string or before a newline character @samp{\n}.
+of the string or before a newline character.
For historical compatibility reasons, @samp{$} can be used only at the
end of the regular expression, or before @samp{\)} or @samp{\|}.
can act. It is poor practice to depend on this behavior; quote the
special character anyway, regardless of where it appears.@refill
+As a @samp{\} is not special inside a character alternative, it can
+never remove the special meaning of @samp{-} or @samp{]}. So you
+should not quote these characters when they have no special meaning
+either. This would not clarify anything, since backslashes can
+legitimately precede these characters where they @emph{have} special
+meaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),
+which matches any single character except a backslash.
+
+In practice, most @samp{]} that occur in regular expressions close a
+character alternative and hence are special. However, occasionally a
+regular expression may try to match a complex pattern of literal
+@samp{[} and @samp{]}. In such situations, it sometimes may be
+necessary to carefully parse the regexp from the start to determine
+which square brackets enclose a character alternative. For example,
+@samp{[^][]]} consists of the complemented character alternative
+@samp{[^][]} (which matches any single character that is not a square
+bracket), followed by a literal @samp{]}.
+
+The exact rules are that at the beginning of a regexp, @samp{[} is
+special and @samp{]} not. This lasts until the first unquoted
+@samp{[}, after which we are in a character alternative; @samp{[} is
+no longer special (except when it starts a character class) but @samp{]}
+is special, unless it immediately follows the special @samp{[} or that
+@samp{[} followed by a @samp{^}. This lasts until the next special
+@samp{]} that does not end a character class. This ends the character
+alternative and restores the ordinary syntax of regular expressions;
+an unquoted @samp{[} is special again and a @samp{]} not.
+
@node Char Classes
@subsubsection Character Classes
@cindex character classes in regexp
Here is a table of the classes you can use in a character alternative,
-in Emacs 21, and what they mean:
+and what they mean:
@table @samp
@item [:ascii:]
-This matches any @sc{ascii} (unibyte) character.
+This matches any @acronym{ASCII} (unibyte) character.
@item [:alnum:]
This matches any letter or digit. (At present, for multibyte
characters, it matches anything that has word syntax.)
@item [:blank:]
This matches space and tab only.
@item [:cntrl:]
-This matches any @sc{ascii} control character.
+This matches any @acronym{ASCII} control character.
@item [:digit:]
This matches @samp{0} through @samp{9}. Thus, @samp{[-+[:digit:]]}
matches any digit, as well as @samp{+} and @samp{-}.
@item [:graph:]
-This matches graphic characters---everything except @sc{ascii} control characters,
-space, and DEL.
+This matches graphic characters---everything except @acronym{ASCII} control
+characters, space, and the delete character.
@item [:lower:]
This matches any lower-case letter, as determined by
the current case table (@pxref{Case Tables}).
@item [:nonascii:]
-This matches any non-@sc{ascii} (multibyte) character.
+This matches any non-@acronym{ASCII} (multibyte) character.
@item [:print:]
-This matches printing characters---everything except @sc{ascii} control
+This matches printing characters---everything except @acronym{ASCII} control
characters and the delete character.
@item [:punct:]
This matches any punctuation character. (At present, for multibyte
surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
@samp{\|}.@refill
-Full backtracking capability exists to handle multiple uses of
-@samp{\|}, if you use the POSIX regular expression functions
-(@pxref{POSIX Regexps}).
+If you need full backtracking capability to handle multiple uses of
+@samp{\|}, use the POSIX regular expression functions (@pxref{POSIX
+Regexps}).
+
+@item \@{@var{m}\@}
+is a postfix operator that repeats the previous pattern exactly @var{m}
+times. Thus, @samp{x\@{5\@}} matches the string @samp{xxxxx}
+and nothing else. @samp{c[ad]\@{3\@}r} matches string such as
+@samp{caaar}, @samp{cdddr}, @samp{cadar}, and so on.
+
+@item \@{@var{m},@var{n}\@}
+is a more general postfix operator that specifies repetition with a
+minimum of @var{m} repeats and a maximum of @var{n} repeats. If @var{m}
+is omitted, the minimum is 0; if @var{n} is omitted, there is no
+maximum.
+
+For example, @samp{c[ad]\@{1,2\@}r} matches the strings @samp{car},
+@samp{cdr}, @samp{caar}, @samp{cadr}, @samp{cdar}, and @samp{cddr}, and
+nothing else.@*
+@samp{\@{0,1\@}} or @samp{\@{,1\@}} is equivalent to @samp{?}. @*
+@samp{\@{0,\@}} or @samp{\@{,\@}} is equivalent to @samp{*}. @*
+@samp{\@{1,\@}} is equivalent to @samp{+}.
@item \( @dots{} \)
@cindex @samp{(} in regexp
number (zero or more) of @samp{na} strings.
@item
-To record a matched substring for future reference.
+To record a matched substring for future reference with
+@samp{\@var{digit}} (see below).
@end enumerate
This last application is not a consequence of the idea of a
-parenthetical grouping; it is a separate feature that happens to be
-assigned as a second meaning to the same @samp{\( @dots{} \)} construct
-because there is no conflict in practice between the two meanings.
-Here is an explanation of this feature:
+parenthetical grouping; it is a separate feature that was assigned as a
+second meaning to the same @samp{\( @dots{} \)} construct because, in
+practice, there was usually no conflict between the two meanings. But
+occasionally there is a conflict, and that led to the introduction of
+shy groups.
+
+@item \(?: @dots{} \)
+is the @dfn{shy group} construct. A shy group serves the first two
+purposes of an ordinary group (controlling the nesting of other
+operators), but it does not get a number, so you cannot refer back to
+its value with @samp{\@var{digit}}.
+
+Shy groups are particularly useful for mechanically-constructed regular
+expressions because they can be added automatically without altering the
+numbering of any ordinary, non-shy groups.
@item \@var{digit}
matches the same text that matched the @var{digit}th occurrence of a
-@samp{\( @dots{} \)} construct.
+grouping (@samp{\( @dots{} \)}) construct.
-In other words, after the end of a @samp{\( @dots{} \)} construct, the
-matcher remembers the beginning and end of the text matched by that
-construct. Then, later on in the regular expression, you can use
-@samp{\} followed by @var{digit} to match that same text, whatever it
-may have been.
+In other words, after the end of a group, the matcher remembers the
+beginning and end of the text matched by that group. Later on in the
+regular expression you can use @samp{\} followed by @var{digit} to
+match that same text, whatever it may have been.
-The strings matching the first nine @samp{\( @dots{} \)} constructs
-appearing in a regular expression are assigned numbers 1 through 9 in
-the order that the open parentheses appear in the regular expression.
-So you can use @samp{\1} through @samp{\9} to refer to the text matched
-by the corresponding @samp{\( @dots{} \)} constructs.
+The strings matching the first nine grouping constructs appearing in
+the entire regular expression passed to a search or matching function
+are assigned numbers 1 through 9 in the order that the open
+parentheses appear in the regular expression. So you can use
+@samp{\1} through @samp{\9} to refer to the text matched by the
+corresponding grouping constructs.
For example, @samp{\(.*\)\1} matches any newline-free string that is
composed of two identical halves. The @samp{\(.*\)} matches the first
half, which may be anything, but the @samp{\1} that follows must match
the same exact text.
+If a @samp{\( @dots{} \)} construct matches more than once (which can
+happen, for instance, if it is followed by @samp{*}), only the last
+match is recorded.
+
+If a particular grouping construct in the regular expression was never
+matched---for instance, if it appears inside of an alternative that
+wasn't used, or inside of a repetition that repeated zero times---then
+the corresponding @samp{\@var{digit}} construct never matches
+anything. To use an artificial example,, @samp{\(foo\(b*\)\|lose\)\2}
+cannot match @samp{lose}: the second alternative inside the larger
+group matches it, but then @samp{\2} is undefined and can't match
+anything. But it can match @samp{foobb}, because the first
+alternative matches @samp{foob} and @samp{\2} matches @samp{b}.
+
@item \w
@cindex @samp{\w} in regexp
matches any word-constituent character. The editor syntax table
@item \S@var{code}
@cindex @samp{\S} in regexp
matches any character whose syntax is not @var{code}.
+
+@item \c@var{c}
+matches any character whose category is @var{c}. Here @var{c} is a
+character that represents a category: thus, @samp{c} for Chinese
+characters or @samp{g} for Greek characters in the standard category
+table.
+
+@item \C@var{c}
+matches any character whose category is not @var{c}.
@end table
The following regular expression constructs match the empty string---that is,
they don't use up any characters---but whether they match depends on the
-context.
+context. For all, the beginning and end of the accessible portion of
+the buffer are treated as if they were the actual beginning and end of
+the buffer.
@table @samp
@item \`
@samp{foo} as a separate word. @samp{\bballs?\b} matches
@samp{ball} or @samp{balls} as a separate word.@refill
-@samp{\b} matches at the beginning or end of the buffer
+@samp{\b} matches at the beginning or end of the buffer (or string)
regardless of what text appears next to it.
@item \B
@cindex @samp{\B} in regexp
matches the empty string, but @emph{not} at the beginning or
-end of a word.
+end of a word, nor at the beginning or end of the buffer (or string).
@item \<
@cindex @samp{\<} in regexp
matches the empty string, but only at the beginning of a word.
-@samp{\<} matches at the beginning of the buffer only if a
+@samp{\<} matches at the beginning of the buffer (or string) only if a
word-constituent character follows.
@item \>
@cindex @samp{\>} in regexp
matches the empty string, but only at the end of a word. @samp{\>}
-matches at the end of the buffer only if the contents end with a
-word-constituent character.
+matches at the end of the buffer (or string) only if the contents end
+with a word-constituent character.
+
+@item \_<
+@cindex @samp{\_<} in regexp
+matches the empty string, but only at the beginning of a symbol. A
+symbol is a sequence of one or more word or symbol constituent
+characters. @samp{\_<} matches at the beginning of the buffer (or
+string) only if a symbol-constituent character follows.
+
+@item \_>
+@cindex @samp{\_>} in regexp
+matches the empty string, but only at the end of a symbol. @samp{\_>}
+matches at the end of the buffer (or string) only if the contents end
+with a symbol-constituent character.
@end table
@kindex invalid-regexp
Not every string is a valid regular expression. For example, a string
-with unbalanced square brackets is invalid (with a few exceptions, such
-as @samp{[]]}), and so is a string that ends with a single @samp{\}. If
+that ends inside a character alternative without terminating @samp{]}
+is invalid, and so is a string that ends with a single @samp{\}. If
an invalid regular expression is passed to any of the search functions,
an @code{invalid-regexp} error is signaled.
@comment node-name, next, previous, up
@subsection Complex Regexp Example
- Here is a complicated regexp, used by Emacs to recognize the end of a
-sentence together with any whitespace that follows. It is the value of
-the variable @code{sentence-end}.
+ Here is a complicated regexp which was formerly used by Emacs to
+recognize the end of a sentence together with any whitespace that
+follows. (Nowadays Emacs uses a similar but more complex default
+regexp constructed by the function @code{sentence-end}.
+@xref{Standard Regexps}.)
First, we show the regexp as a string in Lisp syntax to distinguish
spaces from tab characters. The string constant begins and ends with a
tab and @samp{\n} for a newline.
@example
-"[.?!][]\"')@}]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
+"[.?!][]\"')@}]*\\($\\| $\\|\t\\|@ @ \\)[ \t\n]*"
@end example
@noindent
-In contrast, if you evaluate the variable @code{sentence-end}, you
-will see the following:
+In contrast, if you evaluate this string, you will see the following:
@example
@group
-sentence-end
- @result{} "[.?!][]\"')@}]*\\($\\| $\\| \\| \\)[
+"[.?!][]\"')@}]*\\($\\| $\\|\t\\|@ @ \\)[ \t\n]*"
+ @result{} "[.?!][]\"')@}]*\\($\\| $\\| \\|@ @ \\)[
]*"
@end group
@end example
@item [.?!]
The first part of the pattern is a character alternative that matches
any one of three characters: period, question mark, and exclamation
-mark. The match must begin with one of these three characters.
+mark. The match must begin with one of these three characters. (This
+is one point where the new default regexp used by Emacs differs from
+the old. The new value also allows some non-@acronym{ASCII}
+characters that end a sentence without any following whitespace.)
@item []\"')@}]*
The second part of the pattern matches any closing braces and quotation
@defun regexp-opt strings &optional paren
This function returns an efficient regular expression that will match
-any of the strings @var{strings}. This is useful when you need to make
-matching or searching as fast as possible---for example, for Font Lock
-mode.
+any of the strings in the list @var{strings}. This is useful when you
+need to make matching or searching as fast as possible---for example,
+for Font Lock mode.
If the optional argument @var{paren} is non-@code{nil}, then the
returned regular expression is always enclosed by at least one
-parentheses-grouping construct.
+parentheses-grouping construct. If @var{paren} is @code{words}, then
+that construct is additionally surrounded by @samp{\<} and @samp{\>}.
This simplified definition of @code{regexp-opt} produces a
regular expression which is equivalent to the actual value
@defun regexp-opt-depth regexp
This function returns the total number of grouping constructs
-(parenthesized expressions) in @var{regexp}.
+(parenthesized expressions) in @var{regexp}. (This does not include
+shy groups.)
@end defun
@node Regexp Search
@var{regexp}, and leaves point at the end of the first match found.
It returns the new value of point.
-If @var{limit} is non-@code{nil} (it must be a position in the current
-buffer), then it is the upper bound to the search. No match extending
-after that position is accepted.
+If @var{limit} is non-@code{nil}, it must be a position in the current
+buffer. It specifies the upper bound to the search. No match
+extending after that position is accepted.
-If @var{repeat} is supplied (it must be a positive number), then the
-search is repeated that many times (each time starting at the end of the
-previous time's match). If all these successive searches succeed, the
-function succeeds, moving point and returning its new value. Otherwise
-the function fails.
+If @var{repeat} is supplied, it must be a positive number; the search
+is repeated that many times; each repetition starts at the end of the
+previous match. If all these successive searches succeed, the search
+succeeds, moving point and returning its new value. Otherwise the
+search fails. What @code{re-search-forward} does when the search
+fails depends on the value of @var{noerror}:
-What happens when the function fails depends on the value of
-@var{noerror}. If @var{noerror} is @code{nil}, a @code{search-failed}
-error is signaled. If @var{noerror} is @code{t},
-@code{re-search-forward} does nothing and returns @code{nil}. If
-@var{noerror} is neither @code{nil} nor @code{t}, then
-@code{re-search-forward} moves point to @var{limit} (or the end of the
-buffer) and returns @code{nil}.
+@table @asis
+@item @code{nil}
+Signal a @code{search-failed} error.
+@item @code{t}
+Do nothing and return @code{nil}.
+@item anything else
+Move point to @var{limit} (or the end of the accessible portion of the
+buffer) and return @code{nil}.
+@end table
In the following example, point is initially before the @samp{T}.
Evaluating the search call moves point to the end of that line (between
beginning is as close as possible to the starting point. If
@code{re-search-backward} were a perfect mirror image, it would find the
match whose end is as close as possible. However, in fact it finds the
-match whose beginning is as close as possible. The reason for this is that
-matching a regular expression at a given spot always works from
-beginning to end, and starts at a specified beginning position.
+match whose beginning is as close as possible (and yet ends before the
+starting point). The reason for this is that matching a regular
+expression at a given spot always works from beginning to end, and
+starts at a specified beginning position.
A true mirror-image of @code{re-search-forward} would require a special
feature for matching regular expressions from end to beginning. It's
@end example
@end defun
+@defun looking-back regexp &optional limit
+This function returns @code{t} if @var{regexp} matches text before
+point, ending at point, and @code{nil} otherwise.
+
+Because regular expression matching works only going forward, this is
+implemented by searching backwards from point for a match that ends at
+point. That can be quite slow if it has to search a long distance.
+You can bound the time required by specifying @var{limit}, which says
+not to search before @var{limit}. In this case, the match that is
+found must begin at or after @var{limit}.
+
+@example
+@group
+---------- Buffer: foo ----------
+I read "@point{}The cat in the hat
+comes back" twice.
+---------- Buffer: foo ----------
+
+(looking-back "read \"" 3)
+ @result{} t
+(looking-back "read \"" 4)
+ @result{} nil
+@end group
+@end example
+@end defun
+
+@defvar search-spaces-regexp
+If this variable is non-@code{nil}, it should be a regular expression
+that says how to search for whitespace. In that case, any group of
+spaces in a regular expression being searched for stands for use of
+this regular expression. However, spaces inside of constructs such as
+@samp{[@dots{}]} and @samp{*}, @samp{+}, @samp{?} are not affected by
+@code{search-spaces-regexp}.
+
+Since this variable affects all regular expression search and match
+constructs, you should bind it temporarily for as small as possible
+a part of the code.
+@end defvar
+
@node POSIX Regexps
@section POSIX Regular Expression Searching
match, as required by POSIX. This is much slower, so use these
functions only when you really need the longest match.
+ The POSIX search and match functions do not properly support the
+non-greedy repetition operators. This is because POSIX backtracking
+conflicts with the semantics of non-greedy repetition.
+
@defun posix-search-forward regexp &optional limit noerror repeat
This is like @code{re-search-forward} except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
@end defun
-@ignore
-@deffn Command delete-matching-lines regexp
-This function is identical to @code{delete-non-matching-lines}, save
-that it deletes what @code{delete-non-matching-lines} keeps.
-
-In the example below, point is located on the first line of text.
-
-@example
-@group
----------- Buffer: foo ----------
-We hold these truths
-to be self-evident,
-that all men are created
-equal, and that they are
----------- Buffer: foo ----------
-@end group
-
-@group
-(delete-matching-lines "the")
- @result{} nil
-
----------- Buffer: foo ----------
-to be self-evident,
-that all men are created
----------- Buffer: foo ----------
-@end group
-@end example
-@end deffn
-
-@deffn Command flush-lines regexp
-This function is the same as @code{delete-matching-lines}.
-@end deffn
-
-@defun delete-non-matching-lines regexp
-This function deletes all lines following point which don't
-contain a match for the regular expression @var{regexp}.
-@end defun
-
-@deffn Command keep-lines regexp
-This function is the same as @code{delete-non-matching-lines}.
-@end deffn
-
-@deffn Command how-many regexp
-This function counts the number of matches for @var{regexp} there are in
-the current buffer following point. It prints this number in
-the echo area, returning the string printed.
-@end deffn
-
-@deffn Command count-matches regexp
-This function is a synonym of @code{how-many}.
-@end deffn
-
-@deffn Command list-matching-lines regexp &optional nlines
-This function is a synonym of @code{occur}.
-Show all lines following point containing a match for @var{regexp}.
-Display each line with @var{nlines} lines before and after,
-or @code{-}@var{nlines} before if @var{nlines} is negative.
-@var{nlines} defaults to @code{list-matching-lines-default-context-lines}.
-Interactively it is the prefix arg.
-
-The lines are shown in a buffer named @samp{*Occur*}.
-It serves as a menu to find any of the occurrences in this buffer.
-@kbd{C-h m} (@code{describe-mode}) in that buffer gives help.
-@end deffn
-
-@defopt list-matching-lines-default-context-lines
-Default value is 0.
-Default number of context lines to include around a @code{list-matching-lines}
-match. A negative number means to include that many lines before the match.
-A positive number means to include that many lines both before and after.
-@end defopt
-@end ignore
-
-@node Search and Replace
-@section Search and Replace
-@cindex replacement
-
-@defun perform-replace from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map
-This function is the guts of @code{query-replace} and related commands.
-It searches for occurrences of @var{from-string} and replaces some or
-all of them. If @var{query-flag} is @code{nil}, it replaces all
-occurrences; otherwise, it asks the user what to do about each one.
-
-If @var{regexp-flag} is non-@code{nil}, then @var{from-string} is
-considered a regular expression; otherwise, it must match literally. If
-@var{delimited-flag} is non-@code{nil}, then only replacements
-surrounded by word boundaries are considered.
-
-The argument @var{replacements} specifies what to replace occurrences
-with. If it is a string, that string is used. It can also be a list of
-strings, to be used in cyclic order.
-
-If @var{replacements} is a cons cell, @code{(@var{function}
-. @var{data})}, this means to call @var{function} after each match to
-get the replacement text. This function is called with two arguments:
-@var{data}, and the number of replacements already made.
-
-If @var{repeat-count} is non-@code{nil}, it should be an integer. Then
-it specifies how many times to use each of the strings in the
-@var{replacements} list before advancing cyclicly to the next one.
-
-If @var{from-string} contains upper-case letters, then
-@code{perform-replace} binds @code{case-fold-search} to @code{nil}, and
-it uses the @code{replacements} without altering the case of them.
-
-Normally, the keymap @code{query-replace-map} defines the possible user
-responses for queries. The argument @var{map}, if non-@code{nil}, is a
-keymap to use instead of @code{query-replace-map}.
-@end defun
-
-@defvar query-replace-map
-This variable holds a special keymap that defines the valid user
-responses for @code{query-replace} and related functions, as well as
-@code{y-or-n-p} and @code{map-y-or-n-p}. It is unusual in two ways:
-
-@itemize @bullet
-@item
-The ``key bindings'' are not commands, just symbols that are meaningful
-to the functions that use this map.
-
-@item
-Prefix keys are not supported; each key binding must be for a
-single-event key sequence. This is because the functions don't use
-@code{read-key-sequence} to get the input; instead, they read a single
-event and look it up ``by hand.''
-@end itemize
-@end defvar
-
-Here are the meaningful ``bindings'' for @code{query-replace-map}.
-Several of them are meaningful only for @code{query-replace} and
-friends.
-
-@table @code
-@item act
-Do take the action being considered---in other words, ``yes.''
-
-@item skip
-Do not take action for this question---in other words, ``no.''
-
-@item exit
-Answer this question ``no,'' and give up on the entire series of
-questions, assuming that the answers will be ``no.''
-
-@item act-and-exit
-Answer this question ``yes,'' and give up on the entire series of
-questions, assuming that subsequent answers will be ``no.''
-
-@item act-and-show
-Answer this question ``yes,'' but show the results---don't advance yet
-to the next question.
-
-@item automatic
-Answer this question and all subsequent questions in the series with
-``yes,'' without further user interaction.
-
-@item backup
-Move back to the previous place that a question was asked about.
-
-@item edit
-Enter a recursive edit to deal with this question---instead of any
-other action that would normally be taken.
-
-@item delete-and-edit
-Delete the text being considered, then enter a recursive edit to replace
-it.
-
-@item recenter
-Redisplay and center the window, then ask the same question again.
-
-@item quit
-Perform a quit right away. Only @code{y-or-n-p} and related functions
-use this answer.
-
-@item help
-Display some help, then ask again.
-@end table
-
@node Match Data
@section The Match Data
@cindex match data
Emacs keeps track of the start and end positions of the segments of
-text found during a regular expression search. This means, for example,
-that you can search for a complex pattern, such as a date in an Rmail
-message, and then extract parts of the match under control of the
-pattern.
+text found during a search; this is called the @dfn{match data}.
+Thanks to the match data, you can search for a complex pattern, such
+as a date in a mail message, and then extract parts of the match under
+control of the pattern.
Because the match data normally describe the most recent search only,
you must be careful not to do another search inadvertently between the
@node Replacing Match
@subsection Replacing the Text that Matched
- This function replaces the text matched by the last search with
-@var{replacement}.
+ This function replaces all or part of the text matched by the last
+search. It works by means of the match data.
@cindex case in replacements
@defun replace-match replacement &optional fixedcase literal string subexp
@var{replacement}.
If you did the last search in a buffer, you should specify @code{nil}
-for @var{string}. Then @code{replace-match} does the replacement by
-editing the buffer; it leaves point at the end of the replacement text,
-and returns @code{t}.
+for @var{string} and make sure that the current buffer when you call
+@code{replace-match} is the one in which you did the searching or
+matching. Then @code{replace-match} does the replacement by editing
+the buffer; it leaves point at the end of the replacement text, and
+returns @code{t}.
If you did the search in a string, pass the same string as @var{string}.
Then @code{replace-match} does the replacement by constructing and
returning a new string.
-If @var{fixedcase} is non-@code{nil}, then the case of the replacement
-text is not changed; otherwise, the replacement text is converted to a
-different case depending upon the capitalization of the text to be
-replaced. If the original text is all upper case, the replacement text
-is converted to upper case. If the first word of the original text is
-capitalized, then the first word of the replacement text is capitalized.
-If the original text contains just one word, and that word is a capital
-letter, @code{replace-match} considers this a capitalized first word
-rather than all upper case.
+If @var{fixedcase} is non-@code{nil}, then @code{replace-match} uses
+the replacement text without case conversion; otherwise, it converts
+the replacement text depending upon the capitalization of the text to
+be replaced. If the original text is all upper case, this converts
+the replacement text to upper case. If all words of the original text
+are capitalized, this capitalizes all the words of the replacement
+text. If all the words are one-letter and they are all upper case,
+they are treated as capitalized words rather than all-upper-case
+words.
If @var{literal} is non-@code{nil}, then @var{replacement} is inserted
exactly as it is, the only alterations being case changes as needed.
@samp{\@var{n}}, where @var{n} is a digit, stands for the text that
matched the @var{n}th subexpression in the original regexp.
Subexpressions are those expressions grouped inside @samp{\(@dots{}\)}.
+If the @var{n}th subexpression never matched, an empty string is substituted.
@item @samp{\\}
@cindex @samp{\} in replacement
@samp{\\} stands for a single @samp{\} in the replacement text.
@end table
+These substitutions occur after case conversion, if any,
+so the strings they substitute are never case-converted.
+
If @var{subexp} is non-@code{nil}, that says to replace just
subexpression number @var{subexp} of the regexp that was matched, not
the entire match. For example, after matching @samp{foo \(ba*r\)},
@subsection Simple Match Data Access
This section explains how to use the match data to find out what was
-matched by the last search or match operation.
+matched by the last search or match operation, if it succeeded.
You can ask about the entire matching text, or about a particular
parenthetical subexpression of a regular expression. The @var{count}
A search which fails may or may not alter the match data. In the
past, a failing search did not do this, but we may change it in the
-future.
+future. So don't try to rely on the value of the match data after
+a failing search.
@defun match-string count &optional in-string
This function returns, as a string, the text matched in the last search
or match operation. It returns the entire text if @var{count} is zero,
or just the portion corresponding to the @var{count}th parenthetical
-subexpression, if @var{count} is positive. If @var{count} is out of
-range, or if that subexpression didn't match anything, the value is
-@code{nil}.
+subexpression, if @var{count} is positive.
If the last such operation was done against a string with
@code{string-match}, then you should pass the same string as the
should make sure that the current buffer when you call
@code{match-string} is the one in which you did the searching or
matching.
+
+The value is @code{nil} if @var{count} is out of range, or for a
+subexpression inside a @samp{\|} alternative that wasn't used or a
+repetition that repeated zero times.
@end defun
@defun match-string-no-properties count &optional in-string
position of the match for that subexpression.
The value is @code{nil} for a subexpression inside a @samp{\|}
-alternative that wasn't used in the match.
+alternative that wasn't used or a repetition that repeated zero times.
@end defun
@defun match-end count
@group
(string-match "\\(qu\\)\\(ick\\)"
"The quick fox jumped quickly.")
- ;0123456789
+ ;0123456789
@result{} 4
@end group
The functions @code{match-data} and @code{set-match-data} read or
write the entire match data, all at once.
-@defun match-data
-This function returns a newly constructed list containing all the
-information on what text the last search matched. Element zero is the
-position of the beginning of the match for the whole expression; element
-one is the position of the end of the match for the expression. The
-next two elements are the positions of the beginning and end of the
-match for the first subexpression, and so on. In general, element
+@defun match-data &optional integers reuse reseat
+This function returns a list of positions (markers or integers) that
+record all the information on what text the last search matched.
+Element zero is the position of the beginning of the match for the
+whole expression; element one is the position of the end of the match
+for the expression. The next two elements are the positions of the
+beginning and end of the match for the first subexpression, and so on.
+In general, element
@ifnottex
number 2@var{n}
@end ifnottex
@end tex
corresponds to @code{(match-end @var{n})}.
-All the elements are markers or @code{nil} if matching was done on a
-buffer, and all are integers or @code{nil} if matching was done on a
-string with @code{string-match}.
+Normally all the elements are markers or @code{nil}, but if
+@var{integers} is non-@code{nil}, that means to use integers instead
+of markers. (In that case, the buffer itself is appended as an
+additional element at the end of the list, to facilitate complete
+restoration of the match data.) If the last match was done on a
+string with @code{string-match}, then integers are always used,
+since markers can't point into a string.
+
+If @var{reuse} is non-@code{nil}, it should be a list. In that case,
+@code{match-data} stores the match data in @var{reuse}. That is,
+@var{reuse} is destructively modified. @var{reuse} does not need to
+have the right length. If it is not long enough to contain the match
+data, it is extended. If it is too long, the length of @var{reuse}
+stays the same, but the elements that were not used are set to
+@code{nil}. The purpose of this feature is to reduce the need for
+garbage collection.
+
+If @var{reseat} is non-@code{nil}, all markers on the @var{reuse} list
+are reseated to point to nowhere.
As always, there must be no possibility of intervening searches between
the call to a search function and the call to @code{match-data} that is
@end example
@end defun
-@defun set-match-data match-list
+@defun set-match-data match-list &optional reseat
This function sets the match data from the elements of @var{match-list},
which should be a list that was the value of a previous call to
-@code{match-data}.
+@code{match-data}. (More precisely, anything that has the same format
+will work.)
If @var{match-list} refers to a buffer that doesn't exist, you don't get
an error; that sets the match data in a meaningless but harmless way.
+If @var{reseat} is non-@code{nil}, all markers on the @var{match-list} list
+are reseated to point to nowhere.
+
@findex store-match-data
@code{store-match-data} is a semi-obsolete alias for @code{set-match-data}.
@end defun
@defmac save-match-data body@dots{}
This macro executes @var{body}, saving and restoring the match
-data around it.
+data around it. The return value is the value of the last form in
+@var{body}.
@end defmac
You could use @code{set-match-data} together with @code{match-data} to
@end smallexample
@end ignore
-@node Searching and Case
-@section Searching and Case
-@cindex searching and case
+@node Search and Replace
+@section Search and Replace
+@cindex replacement
- By default, searches in Emacs ignore the case of the text they are
-searching through; if you specify searching for @samp{FOO}, then
-@samp{Foo} or @samp{foo} is also considered a match. This applies to
-regular expressions, too; thus, @samp{[aB]} would match @samp{a} or
-@samp{A} or @samp{b} or @samp{B}.
+ If you want to find all matches for a regexp in part of the buffer,
+and replace them, the best way is to write an explicit loop using
+@code{re-search-forward} and @code{replace-match}, like this:
- If you do not want this feature, set the variable
-@code{case-fold-search} to @code{nil}. Then all letters must match
-exactly, including case. This is a buffer-local variable; altering the
-variable affects only the current buffer. (@xref{Intro to
-Buffer-Local}.) Alternatively, you may change the value of
-@code{default-case-fold-search}, which is the default value of
-@code{case-fold-search} for buffers that do not override it.
+@example
+(while (re-search-forward "foo[ \t]+bar" nil t)
+ (replace-match "foobar"))
+@end example
- Note that the user-level incremental search feature handles case
-distinctions differently. When given a lower case letter, it looks for
-a match of either case, but when given an upper case letter, it looks
-for an upper case letter only. But this has nothing to do with the
-searching functions used in Lisp code.
+@noindent
+@xref{Replacing Match,, Replacing the Text that Matched}, for a
+description of @code{replace-match}.
+
+ However, replacing matches in a string is more complex, especially
+if you want to do it efficiently. So Emacs provides a function to do
+this.
+
+@defun replace-regexp-in-string regexp rep string &optional fixedcase literal subexp start
+This function copies @var{string} and searches it for matches for
+@var{regexp}, and replaces them with @var{rep}. It returns the
+modified copy. If @var{start} is non-@code{nil}, the search for
+matches starts at that index in @var{string}, so matches starting
+before that index are not changed.
+
+This function uses @code{replace-match} to do the replacement, and it
+passes the optional arguments @var{fixedcase}, @var{literal} and
+@var{subexp} along to @code{replace-match}.
+
+Instead of a string, @var{rep} can be a function. In that case,
+@code{replace-regexp-in-string} calls @var{rep} for each match,
+passing the text of the match as its sole argument. It collects the
+value @var{rep} returns and passes that to @code{replace-match} as the
+replacement string. The match-data at this point are the result
+of matching @var{regexp} against a substring of @var{string}.
+@end defun
-@defopt case-replace
-This variable determines whether the replacement functions should
-preserve case. If the variable is @code{nil}, that means to use the
-replacement text verbatim. A non-@code{nil} value means to convert the
-case of the replacement text according to the text being replaced.
+ If you want to write a command along the lines of @code{query-replace},
+you can use @code{perform-replace} to do the work.
-This variable is used by passing it as an argument to the function
-@code{replace-match}. @xref{Replacing Match}.
-@end defopt
+@defun perform-replace from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map start end
+This function is the guts of @code{query-replace} and related
+commands. It searches for occurrences of @var{from-string} in the
+text between positions @var{start} and @var{end} and replaces some or
+all of them. If @var{start} is @code{nil} (or omitted), point is used
+instead, and the end of the buffer's accessible portion is used for
+@var{end}.
-@defopt case-fold-search
-This buffer-local variable determines whether searches should ignore
-case. If the variable is @code{nil} they do not ignore case; otherwise
-they do ignore case.
-@end defopt
+If @var{query-flag} is @code{nil}, it replaces all
+occurrences; otherwise, it asks the user what to do about each one.
-@defvar default-case-fold-search
-The value of this variable is the default value for
-@code{case-fold-search} in buffers that do not override it. This is the
-same as @code{(default-value 'case-fold-search)}.
+If @var{regexp-flag} is non-@code{nil}, then @var{from-string} is
+considered a regular expression; otherwise, it must match literally. If
+@var{delimited-flag} is non-@code{nil}, then only replacements
+surrounded by word boundaries are considered.
+
+The argument @var{replacements} specifies what to replace occurrences
+with. If it is a string, that string is used. It can also be a list of
+strings, to be used in cyclic order.
+
+If @var{replacements} is a cons cell, @code{(@var{function}
+. @var{data})}, this means to call @var{function} after each match to
+get the replacement text. This function is called with two arguments:
+@var{data}, and the number of replacements already made.
+
+If @var{repeat-count} is non-@code{nil}, it should be an integer. Then
+it specifies how many times to use each of the strings in the
+@var{replacements} list before advancing cyclically to the next one.
+
+If @var{from-string} contains upper-case letters, then
+@code{perform-replace} binds @code{case-fold-search} to @code{nil}, and
+it uses the @code{replacements} without altering the case of them.
+
+Normally, the keymap @code{query-replace-map} defines the possible
+user responses for queries. The argument @var{map}, if
+non-@code{nil}, specifies a keymap to use instead of
+@code{query-replace-map}.
+@end defun
+
+@defvar query-replace-map
+This variable holds a special keymap that defines the valid user
+responses for @code{perform-replace} and the commands that use it, as
+well as @code{y-or-n-p} and @code{map-y-or-n-p}. This map is unusual
+in two ways:
+
+@itemize @bullet
+@item
+The ``key bindings'' are not commands, just symbols that are meaningful
+to the functions that use this map.
+
+@item
+Prefix keys are not supported; each key binding must be for a
+single-event key sequence. This is because the functions don't use
+@code{read-key-sequence} to get the input; instead, they read a single
+event and look it up ``by hand.''
+@end itemize
@end defvar
+Here are the meaningful ``bindings'' for @code{query-replace-map}.
+Several of them are meaningful only for @code{query-replace} and
+friends.
+
+@table @code
+@item act
+Do take the action being considered---in other words, ``yes.''
+
+@item skip
+Do not take action for this question---in other words, ``no.''
+
+@item exit
+Answer this question ``no,'' and give up on the entire series of
+questions, assuming that the answers will be ``no.''
+
+@item act-and-exit
+Answer this question ``yes,'' and give up on the entire series of
+questions, assuming that subsequent answers will be ``no.''
+
+@item act-and-show
+Answer this question ``yes,'' but show the results---don't advance yet
+to the next question.
+
+@item automatic
+Answer this question and all subsequent questions in the series with
+``yes,'' without further user interaction.
+
+@item backup
+Move back to the previous place that a question was asked about.
+
+@item edit
+Enter a recursive edit to deal with this question---instead of any
+other action that would normally be taken.
+
+@item delete-and-edit
+Delete the text being considered, then enter a recursive edit to replace
+it.
+
+@item recenter
+Redisplay and center the window, then ask the same question again.
+
+@item quit
+Perform a quit right away. Only @code{y-or-n-p} and related functions
+use this answer.
+
+@item help
+Display some help, then ask again.
+@end table
+
@node Standard Regexps
@section Standard Regular Expressions Used in Editing
@cindex regexps used standardly in editing
@defvar paragraph-start
This is the regular expression for recognizing the beginning of a line
that starts @emph{or} separates paragraphs. The default value is
-@w{@code{"[@ \t\n\f]"}}, which matches a line starting with a space, tab,
-newline, or form feed (after its left margin).
+@w{@code{"\f\\|[ \t]*$"}}, which matches a line containing only
+whitespace or starting with a form feed (after its left margin).
@end defvar
@defvar sentence-end
-This is the regular expression describing the end of a sentence. (All
-paragraph boundaries also end sentences, regardless.) The default value
-is:
-
-@example
-"[.?!][]\"')@}]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
-@end example
+If non-@code{nil}, the value should be a regular expression describing
+the end of a sentence, including the whitespace following the
+sentence. (All paragraph boundaries also end sentences, regardless.)
+
+If the value is @code{nil}, the default, then the function
+@code{sentence-end} has to construct the regexp. That is why you
+should always call the function @code{sentence-end} to obtain the
+regexp to be used to recognize the end of a sentence.
+@end defvar
-This means a period, question mark or exclamation mark, followed
-optionally by a closing parenthetical character, followed by tabs,
-spaces or new lines.
+@defun sentence-end
+This function returns the value of the variable @code{sentence-end},
+if non-@code{nil}. Otherwise it returns a default value based on the
+values of the variables @code{sentence-end-double-space}
+(@pxref{Definition of sentence-end-double-space}),
+@code{sentence-end-without-period} and
+@code{sentence-end-without-space}.
+@end defun
-For a detailed explanation of this regular expression, see @ref{Regexp
-Example}.
-@end defvar
+@ignore
+ arch-tag: c2573ca2-18aa-4839-93b8-924043ef831f
+@end ignore