@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
+@c 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
These are the primitive functions for searching through the text in a
buffer. They are meant for use in programs, but you may call them
-interactively. If you do so, they prompt for the search string;
-@var{limit} and @var{noerror} are set to @code{nil}, and @var{repeat}
-is set to 1.
+interactively. If you do so, they prompt for the search string; the
+arguments @var{limit} and @var{noerror} are @code{nil}, and @var{repeat}
+is 1.
These search functions convert the search string to multibyte if the
buffer is multibyte; they convert the search string to unibyte if 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, leaving point where it started.
@end deffn
@deffn Command search-backward string &optional limit noerror repeat
@menu
* Syntax of Regexps:: Rules for writing regular expressions.
+* Regexp Functions:: Functions for operating on regular expressions.
* Regexp Example:: Illustrates regular expression syntax.
@end menu
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
+ 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
@samp{f} and no other string. (It does @emph{not} match the string
-@samp{ff}.) Likewise, @samp{o} is a regular expression that matches
-only @samp{o}.@refill
+@samp{fg}, but it does match a @emph{part} of that string.) Likewise,
+@samp{o} is a regular expression that matches only @samp{o}.@refill
-Any two regular expressions @var{a} and @var{b} can be concatenated. The
+ Any two regular expressions @var{a} and @var{b} can be concatenated. The
result is a regular expression that matches a string if @var{a} matches
some amount of the beginning of that string and @var{b} matches the rest of
the string.@refill
-As a simple example, we can concatenate the regular expressions @samp{f}
+ As a simple example, we can concatenate the regular expressions @samp{f}
and @samp{o} to get the regular expression @samp{fo}, which matches only
the string @samp{fo}. Still trivial. To do something more powerful, you
-need to use one of the special characters. Here is a list of them:
+need to use one of the special regular expression constructs.
-@need 1200
+@menu
+* Regexp Special:: Special characters in regular expressions.
+* Char Classes:: Character classes used in regular expressions.
+* Regexp Backslash:: Backslash-sequences in regular expressions.
+@end menu
+
+@node Regexp Special
+@subsubsection Special Characters in Regular Expressions
+
+ Here is a list of the characters that are special in a regular
+expression.
+
+@need 800
@table @asis
@item @samp{.}@: @r{(Period)}
@cindex @samp{.} in regexp
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
+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.
preceding expression either once or not at all. For example,
@samp{ca?r} matches @samp{car} or @samp{cr}; nothing else.
+@item @samp{*?}, @samp{+?}, @samp{??}
+These are ``non-greedy'' variants of the operators @samp{*}, @samp{+}
+and @samp{?}. Where those operators match the largest possible
+substring (consistent with matching the entire containing expression),
+the non-greedy variants match the smallest possible substring
+(consistent with matching the entire containing expression).
+
+For example, the regular expression @samp{c[ad]*a} when applied to the
+string @samp{cdaaada} matches the whole string; but the regular
+expression @samp{c[ad]*?a}, applied to that same string, matches just
+@samp{cda}. (The smallest possible match here for @samp{[ad]*?} that
+permits the whole expression to match is @samp{d}.)
+
@item @samp{[ @dots{} ]}
@cindex character alternative (in regexp)
@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 ASCII letter. Ranges may be
+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 ASCII letter or @samp{$}, @samp{%} or
+which matches any lower case @sc{ascii} letter or @samp{$}, @samp{%} or
period.
-
-You cannot always match all non-@sc{ASCII} characters with the regular
-expression @samp{[\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, in both multibyte and unibyte
-representations, because only the @sc{ASCII} characters are excluded.
-
-The beginning and end of a range must be in the same character set
-(@pxref{Character Sets}). Thus, @samp{[a-\x8c0]} is invalid because
-@samp{a} is in the @sc{ASCII} character set but the character 0x8c0
-(@samp{A} with grave accent) is in the Emacs character set for Latin-1.
Note that the usual regexp special characters are not special inside a
-character alternative. A completely different set of characters are
+character alternative. A completely different set of characters is
special inside character alternatives: @samp{]}, @samp{-} and @samp{^}.
To include a @samp{]} in a character alternative, you must make it the
To include @samp{^} in a character alternative, put it anywhere but at
the beginning.
+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-@sc{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 @code{"[^\000-\177]"}
+does match all non-@sc{ascii} characters (see below regarding @samp{^}),
+in both multibyte and unibyte representations, because only the
+@sc{ascii} characters are excluded.
+
+Starting in Emacs 21, 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
+not feasible in practice, since some classes include thousands of
+different characters.
+
@item @samp{[^ @dots{} ]}
@cindex @samp{^} in regexp
@samp{[^} begins a @dfn{complemented character alternative}, which matches any
the handling of regexps in programs such as @code{grep}.
@item @samp{^}
-@cindex @samp{^} in regexp
@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
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.
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{\|}.
@item @samp{\}
@cindex @samp{\} in regexp
can act. It is poor practice to depend on this behavior; quote the
special character anyway, regardless of where it appears.@refill
-For the most part, @samp{\} followed by any character matches only that
-character. However, there are several exceptions: two-character
-sequences starting with @samp{\} which have special meanings. (The
-second character in such a sequence is always ordinary when used on its
-own.) Here is a table of @samp{\} constructs.
+@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:
+
+@table @samp
+@item [:ascii:]
+This matches any @sc{ascii} (unibyte) character.
+@item [:alnum:]
+This matches any letter or digit. (At present, for multibyte
+characters, it matches anything that has word syntax.)
+@item [:alpha:]
+This matches any letter. (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.
+@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 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.
+@item [:print:]
+This matches printing characters---everything except @sc{ascii} control
+characters and the delete character.
+@item [:punct:]
+This matches any punctuation character. (At present, for multibyte
+characters, it matches anything that has non-word syntax.)
+@item [:space:]
+This matches any character that has whitespace syntax
+(@pxref{Syntax Class Table}).
+@item [:upper:]
+This matches any upper-case letter, as determined by
+the current case table (@pxref{Case Tables}).
+@item [:word:]
+This matches any character that has word syntax (@pxref{Syntax Class
+Table}).
+@item [:xdigit:]
+This matches the hexadecimal digits: @samp{0} through @samp{9}, @samp{a}
+through @samp{f} and @samp{A} through @samp{F}.
+@end table
+
+@node Regexp Backslash
+@subsubsection Backslash Constructs in Regular Expressions
+
+ For the most part, @samp{\} followed by any character matches only
+that character. However, there are several exceptions: certain
+two-character sequences starting with @samp{\} that have special
+meanings. (The character after the @samp{\} in such a sequence is
+always ordinary when used on its own.) Here is a table of the special
+@samp{\} constructs.
@table @samp
@item \|
surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
@samp{\|}.@refill
-Full backtracking capability exists to handle multiple uses of @samp{\|}.
+Full backtracking capability exists to handle multiple uses of
+@samp{\|}, if you 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 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
+pratice, 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 particulary 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 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,
an invalid regular expression is passed to any of the search functions,
an @code{invalid-regexp} error is signaled.
-@defun regexp-quote string
-This function returns a regular expression string that matches exactly
-@var{string} and nothing else. This allows you to request an exact
-string match when calling a function that wants a regular expression.
-
-@example
-@group
-(regexp-quote "^The cat$")
- @result{} "\\^The cat\\$"
-@end group
-@end example
-
-One use of @code{regexp-quote} is to combine an exact string match with
-context described as a regular expression. For example, this searches
-for the string that is the value of @var{string}, surrounded by
-whitespace:
-
-@example
-@group
-(re-search-forward
- (concat "\\s-" (regexp-quote string) "\\s-"))
-@end group
-@end example
-@end defun
-
-@defun regexp-opt strings &optional paren
-@tindex regexp-opt
-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.
-
-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.
-
-This simplified definition of @code{regexp-opt} produces a
-regular expression which is equivalent to the actual value
-(but not as efficient):
-
-@example
-(defun regexp-opt (strings paren)
- (let ((open-paren (if paren "\\(" ""))
- (close-paren (if paren "\\)" "")))
- (concat open-paren
- (mapconcat 'regexp-quote strings "\\|")
- close-paren)))
-@end example
-@end defun
-
-@defun regexp-opt-depth regexp
-@tindex regexp-opt-depth
-This function returns the total number of grouping constructs
-(parenthesized expressions) in @var{regexp}.
-@end defun
-
@node Regexp Example
@comment node-name, next, previous, up
@subsection Complex Regexp Example
beyond the minimum needed to end a sentence.
@end table
+@node Regexp Functions
+@subsection Regular Expression Functions
+
+ These functions operate on regular expressions.
+
+@defun regexp-quote string
+This function returns a regular expression whose only exact match is
+@var{string}. Using this regular expression in @code{looking-at} will
+succeed only if the next characters in the buffer are @var{string};
+using it in a search function will succeed if the text being searched
+contains @var{string}.
+
+This allows you to request an exact string match or search when calling
+a function that wants a regular expression.
+
+@example
+@group
+(regexp-quote "^The cat$")
+ @result{} "\\^The cat\\$"
+@end group
+@end example
+
+One use of @code{regexp-quote} is to combine an exact string match with
+context described as a regular expression. For example, this searches
+for the string that is the value of @var{string}, surrounded by
+whitespace:
+
+@example
+@group
+(re-search-forward
+ (concat "\\s-" (regexp-quote string) "\\s-"))
+@end group
+@end example
+@end defun
+
+@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.
+
+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.
+
+This simplified definition of @code{regexp-opt} produces a
+regular expression which is equivalent to the actual value
+(but not as efficient):
+
+@example
+(defun regexp-opt (strings paren)
+ (let ((open-paren (if paren "\\(" ""))
+ (close-paren (if paren "\\)" "")))
+ (concat open-paren
+ (mapconcat 'regexp-quote strings "\\|")
+ close-paren)))
+@end example
+@end defun
+
+@defun regexp-opt-depth regexp
+This function returns the total number of grouping constructs
+(parenthesized expressions) in @var{regexp}.
+@end defun
+
@node Regexp Search
@section Regular Expression Searching
@cindex regular expression searching
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 is that
+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.
This function is a synonym of @code{how-many}.
@end deffn
-@deffn Command list-matching-lines regexp nlines
+@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,
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.
+@kbd{C-h m} (@code{describe-mode}) in that buffer gives help.
@end deffn
@defopt list-matching-lines-default-context-lines
@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
+@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 buffer's end is used for @var{end}.
+
+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
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}.
@section The Match Data
@cindex match data
- Emacs keeps track of the positions of the start and end of segments of
+ 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
@end menu
@node Replacing Match
-@subsection Replacing the Text That Matched
+@subsection Replacing the Text that Matched
This function replaces the text matched by the last search with
@var{replacement}.
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 @code{case-replace} is @code{nil}, then case conversion is not done,
-regardless of the value of @var{fixed-case}. @xref{Searching and 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{\\} 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\)},
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
+@defun match-string-no-properties count &optional in-string
This function is like @code{match-string} except that the result
has no text properties.
@end defun
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
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
-@ifinfo
+@ifnottex
number 2@var{n}
-@end ifinfo
+@end ifnottex
@tex
number {\mathsurround=0pt $2n$}
@end tex
corresponds to @code{(match-beginning @var{n})}; and
element
-@ifinfo
+@ifnottex
number 2@var{n} + 1
-@end ifinfo
+@end ifnottex
@tex
number {\mathsurround=0pt $2n+1$}
@end tex
@defun set-match-data match-list
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.
You can save and restore the match data with @code{save-match-data}:
@defmac save-match-data body@dots{}
-This special form executes @var{body}, saving and restoring the match
+This macro executes @var{body}, saving and restoring the match
data around it.
@end defmac
replacement text verbatim. A non-@code{nil} value means to convert the
case of the replacement text according to the text being replaced.
-The function @code{replace-match} is where this variable actually has
-its effect. @xref{Replacing Match}.
+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
HCoop / bpt / emacs.git / blobdiff