| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GNU Emacs provides two ways to search through a buffer for specified text: exact string searches and regular expression searches. After a regular expression search, you can examine the match data to determine which text matched the whole regular expression or various portions of it.
34.1 Searching for Strings Search for an exact match. 34.2 Regular Expressions Describing classes of strings. 34.3 Regular Expression Searching Searching for a match for a regexp. 34.4 POSIX Regular Expression Searching Searching POSIX-style for the longest match. 34.5 Search and Replace Internals of query-replace.34.6 The Match Data Finding out which part of the text matched various parts of a regexp, after regexp search. 34.7 Searching and Case Case-independent or case-significant searching. 34.8 Standard Regular Expressions Used in Editing Useful regexps for finding sentences, pages,...
The `skip-chars...' functions also perform a kind of searching. See section 30.2.7 Skipping Characters.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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; the
arguments limit and noerror are nil, and 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 buffer is unibyte. See section 33.1 Text Representations.
In the following example, point is initially at the beginning of the
line. Then (search-forward "fox") moves point after the last
letter of `fox':
---------- Buffer: foo ----------
-!-The quick brown fox jumped over the lazy dog.
---------- Buffer: foo ----------
(search-forward "fox")
=> 20
---------- Buffer: foo ----------
The quick brown fox-!- jumped over the lazy dog.
---------- Buffer: foo ----------
|
The argument limit specifies the upper bound to the search. (It
must be a position in the current buffer.) No match extending after
that position is accepted. If limit is omitted or nil, it
defaults to the end of the accessible portion of the buffer.
What happens when the search fails depends on the value of
noerror. If noerror is nil, a search-failed
error is signaled. If noerror is t, search-forward
returns nil and does nothing. If noerror is neither
nil nor t, then search-forward moves point to the
upper bound and returns nil. (It would be more consistent now to
return the new position of point in that case, but some existing
programs may depend on a value of nil.)
If 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.
search-forward except that it searches backwards and
leaves point at the beginning of the match.
Word matching regards string as a sequence of words, disregarding punctuation that separates them. It searches the buffer for the same sequence of words. Each word must be distinct in the buffer (searching for the word `ball' does not match the word `balls'), but the details of punctuation and spacing are ignored (searching for `ball boy' does match `ball. Boy!').
In this example, point is initially at the beginning of the buffer; the search leaves it between the `y' and the `!'.
---------- Buffer: foo ----------
-!-He said "Please! Find
the ball boy!"
---------- Buffer: foo ----------
(word-search-forward "Please find the ball, boy.")
=> 35
---------- Buffer: foo ----------
He said "Please! Find
the ball boy-!-!"
---------- Buffer: foo ----------
|
If limit is non-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 noerror is nil, then word-search-forward signals
an error if the search fails. If noerror is t, then it
returns nil instead of signaling an error. If noerror is
neither nil nor t, it moves point to limit (or the
end of the buffer) and returns nil.
If repeat is non-nil, then the search is repeated that many
times. Point is positioned at the end of the last match.
word-search-forward
except that it searches backward and normally leaves point at the
beginning of the match.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A regular expression (regexp, for short) is a pattern that denotes a (possibly infinite) set of strings. Searching for matches for a regexp is a very powerful operation. This section explains how to write regexps; the following section says how to search for them.
34.2.1 Syntax of Regular Expressions Rules for writing regular expressions. 34.2.3 Regular Expression Functions Functions for operating on regular expressions. 34.2.2 Complex Regexp Example Illustrates regular expression syntax.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Regular expressions have a syntax in which a few characters are special constructs and the rest are ordinary. An ordinary character is a simple regular expression that matches that character and nothing else. The special characters are `.', `*', `+', `?', `[', `]', `^', `$', and `\'; no new special characters will be defined in the future. Any other character appearing in a regular expression is ordinary, unless a `\' precedes it.
For example, `f' is not a special character, so it is ordinary, and therefore `f' is a regular expression that matches the string `f' and no other string. (It does not match the string `fg', but it does match a part of that string.) Likewise, `o' is a regular expression that matches only `o'.
Any two regular expressions a and b can be concatenated. The result is a regular expression that matches a string if a matches some amount of the beginning of that string and b matches the rest of the string.
As a simple example, we can concatenate the regular expressions `f' and `o' to get the regular expression `fo', which matches only the string `fo'. Still trivial. To do something more powerful, you need to use one of the special regular expression constructs.
34.2.1.1 Special Characters in Regular Expressions Special characters in regular expressions. 34.2.1.2 Character Classes Character classes used in regular expressions. 34.2.1.3 Backslash Constructs in Regular Expressions Backslash-sequences in regular expressions.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here is a list of the characters that are special in a regular expression.
`*' always applies to the smallest possible preceding expression. Thus, `fo*' has a repeating `o', not a repeating `fo'. It matches `f', `fo', `foo', and so on.
The matcher processes a `*' construct by matching, immediately, as many repetitions as can be found. Then it continues with the rest of the pattern. If that fails, backtracking occurs, discarding some of the matches of the `*'-modified construct in the hope that that will make it possible to match the rest of the pattern. For example, in matching `ca*ar' against the string `caaar', the `a*' first tries to match all three `a's; but the rest of the pattern is `ar' and there is only `r' left to match, so this try fails. The next alternative is for `a*' to match only two `a's. With this choice, the rest of the regexp matches successfully.
Nested repetition operators can be extremely slow if they specify backtracking loops. For example, it could take hours for the regular expression `\(x+y*\)*a' to try to match the sequence `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz', before it ultimately fails. The slowness is because Emacs must try each imaginable way of grouping the 35 `x's before concluding that none of them can work. To make sure your regular expressions run fast, check nested repetitions carefully.
For example, the regular expression `c[ad]*a' when applied to the string `cdaaada' matches the whole string; but the regular expression `c[ad]*?a', applied to that same string, matches just `cda'. (The smallest possible match here for `[ad]*?' that permits the whole expression to match is `d'.)
Thus, `[ad]' matches either one `a' or one `d', and `[ad]*' matches any string composed of just `a's and `d's (including the empty string), from which it follows that `c[ad]*r' matches `cr', `car', `cdr', `caddaar', etc.
You can also include character ranges in a character alternative, by writing the starting and ending characters with a `-' between them. Thus, `[a-z]' matches any lower-case ASCII letter. Ranges may be intermixed freely with individual characters, as in `[a-z$%.]', which matches any lower case ASCII letter or `$', `%' or period.
Note that the usual regexp special characters are not special inside a character alternative. A completely different set of characters is special inside character alternatives: `]', `-' and `^'.
To include a `]' in a character alternative, you must make it the first character. For example, `[]a]' matches `]' or `a'. To include a `-', write `-' as the first or last character of the character alternative, or put it after a range. Thus, `[]-]' matches both `]' and `-'.
To include `^' 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 (see section 33.5 Character Sets). Thus,
"[\x8e0-\x97c]" is invalid because character 0x8e0 (`a'
with grave accent) is in the Emacs character set for Latin-1 but the
character 0x97c (`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 c and ends with a
multibyte character c2, the range is divided into two parts: one
is `c..?\377', the other is `c1..c2', where
c1 is the first character of the charset to which c2
belongs.
You cannot always match all non-ASCII characters with the regular
expression "[\200-\377]". This works when searching a unibyte
buffer or string (see section 33.1 Text Representations), but not in a multibyte
buffer or string, because many non-ASCII characters have codes
above octal 0377. However, the regular expression "[^\000-\177]"
does match all non-ASCII characters (see below regarding `^'),
in both multibyte and unibyte representations, because only the
ASCII characters are excluded.
Starting in Emacs 21, a character alternative can also specify named character classes (see section 34.2.1.2 Character Classes). This is a POSIX feature whose syntax is `[: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.
`^' is not special in a character alternative unless it is the first character. The character following the `^' is treated as if it were first (in other words, `-' and `]' are not special there).
A complemented character alternative can match a newline, unless newline is
mentioned as one of the characters not to match. This is in contrast to
the handling of regexps in programs such as grep.
When matching a string instead of a buffer, `^' matches at the beginning of the string or after a newline character.
For historical compatibility reasons, `^' can be used only at the beginning of the regular expression, or after `\(' or `\|'.
When matching a string instead of a buffer, `$' matches at the end of the string or before a newline character.
For historical compatibility reasons, `$' can be used only at the end of the regular expression, or before `\)' or `\|'.
Because `\' quotes special characters, `\$' is a regular expression that matches only `$', and `\[' is a regular expression that matches only `[', and so on.
Note that `\' also has special meaning in the read syntax of Lisp
strings (see section 2.3.8 String Type), and must be quoted with `\'. For
example, the regular expression that matches the `\' character is
`\\'. To write a Lisp string that contains the characters
`\\', Lisp syntax requires you to quote each `\' with another
`\'. Therefore, the read syntax for a regular expression matching
`\' is "\\\\".
Please note: For historical compatibility, special characters are treated as ordinary ones if they are in contexts where their special meanings make no sense. For example, `*foo' treats `*' as ordinary since there is no preceding expression on which the `*' can act. It is poor practice to depend on this behavior; quote the special character anyway, regardless of where it appears.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here is a table of the classes you can use in a character alternative, in Emacs 21, and what they mean:
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
For the most part, `\' followed by any character matches only that character. However, there are several exceptions: certain two-character sequences starting with `\' that have special meanings. (The character after the `\' in such a sequence is always ordinary when used on its own.) Here is a table of the special `\' constructs.
Thus, `foo\|bar' matches either `foo' or `bar' but no other string.
`\|' applies to the largest possible surrounding expressions. Only a surrounding `\( ... \)' grouping can limit the grouping power of `\|'.
Full backtracking capability exists to handle multiple uses of `\|', if you use the POSIX regular expression functions (see section 34.4 POSIX Regular Expression Searching).
For example, `c[ad]\{1,2\}r' matches the strings `car',
`cdr', `caar', `cadr', `cdar', and `cddr', and
nothing else.
`\{0,1\}' or `\{,1\}' is equivalent to `?'.
`\{0,\}' or `\{,\}' is equivalent to `*'.
`\{1,\}' is equivalent to `+'.
This last application is not a consequence of the idea of a parenthetical grouping; it is a separate feature that was assigned as a second meaning to the same `\( ... \)' 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.
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.
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 `\' followed by digit to match that same text, whatever it may have been.
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 `\1' through `\9' to refer to the text matched by the corresponding grouping constructs.
For example, `\(.*\)\1' matches any newline-free string that is composed of two identical halves. The `\(.*\)' matches the first half, which may be anything, but the `\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 `\digit' construct never matches anything. To use an artificial example,, `\(foo\(b*\)\|lose\)\2' cannot match `lose': the second alternative inside the larger group matches it, but then `\2' is undefined and can't match anything. But it can match `foobb', because the first alternative matches `foob' and `\2' matches `b'.
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.
`\b' matches at the beginning or end of the buffer regardless of what text appears next to it.
Not every string is a valid regular expression. For example, a string
with unbalanced square brackets is invalid (with a few exceptions, such
as `[]]'), and so is a string that ends with a single `\'. If
an invalid regular expression is passed to any of the search functions,
an invalid-regexp error is signaled.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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 sentence-end.
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 double-quote. `\"' stands for a double-quote as part of the string, `\\' for a backslash as part of the string, `\t' for a tab and `\n' for a newline.
"[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*" |
In contrast, if you evaluate the variable sentence-end, you
will see the following:
sentence-end
=> "[.?!][]\"')}]*\\($\\| $\\| \\| \\)[
]*"
|
In this output, tab and newline appear as themselves.
This regular expression contains four parts in succession and can be deciphered as follows:
[.?!]
[]\"')}]*
\" is Lisp syntax for a double-quote in
a string. The `*' at the end indicates that the immediately
preceding regular expression (a character alternative, in this case) may be
repeated zero or more times.
\\($\\| $\\|\t\\| \\)
[ \t\n]*
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These functions operate on regular expressions.
looking-at will
succeed only if the next characters in the buffer are string;
using it in a search function will succeed if the text being searched
contains string.
This allows you to request an exact string match or search when calling a function that wants a regular expression.
(regexp-quote "^The cat$")
=> "\\^The cat\\$"
|
One use of 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 string, surrounded by
whitespace:
(re-search-forward (concat "\\s-" (regexp-quote string) "\\s-")) |
If the optional argument paren is non-nil, then the
returned regular expression is always enclosed by at least one
parentheses-grouping construct.
This simplified definition of regexp-opt produces a
regular expression which is equivalent to the actual value
(but not as efficient):
(defun regexp-opt (strings paren)
(let ((open-paren (if paren "\\(" ""))
(close-paren (if paren "\\)" "")))
(concat open-paren
(mapconcat 'regexp-quote strings "\\|")
close-paren)))
|
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In GNU Emacs, you can search for the next match for a regular
expression either incrementally or not. For incremental search
commands, see section `Regular Expression Search' in The GNU Emacs Manual. Here we describe only the search functions
useful in programs. The principal one is re-search-forward.
These search functions convert the regular expression to multibyte if the buffer is multibyte; they convert the regular expression to unibyte if the buffer is unibyte. See section 33.1 Text Representations.
If limit is non-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 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.
What happens when the function fails depends on the value of
noerror. If noerror is nil, a search-failed
error is signaled. If noerror is t,
re-search-forward does nothing and returns nil. If
noerror is neither nil nor t, then
re-search-forward moves point to limit (or the end of the
buffer) and returns nil.
In the following example, point is initially before the `T'. Evaluating the search call moves point to the end of that line (between the `t' of `hat' and the newline).
---------- Buffer: foo ----------
I read "-!-The cat in the hat
comes back" twice.
---------- Buffer: foo ----------
(re-search-forward "[a-z]+" nil t 5)
=> 27
---------- Buffer: foo ----------
I read "The cat in the hat-!-
comes back" twice.
---------- Buffer: foo ----------
|
This function is analogous to re-search-forward, but they are not
simple mirror images. re-search-forward finds the match whose
beginning is as close as possible to the starting point. If
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.
A true mirror-image of re-search-forward would require a special
feature for matching regular expressions from end to beginning. It's
not worth the trouble of implementing that.
nil if
there is no match. If start is non-nil, the search starts
at that index in string.
For example,
(string-match
"quick" "The quick brown fox jumped quickly.")
=> 4
(string-match
"quick" "The quick brown fox jumped quickly." 8)
=> 27
|
The index of the first character of the string is 0, the index of the second character is 1, and so on.
After this function returns, the index of the first character beyond
the match is available as (match-end 0). See section 34.6 The Match Data.
(string-match
"quick" "The quick brown fox jumped quickly." 8)
=> 27
(match-end 0)
=> 32
|
t if so, nil otherwise.
This function does not move point, but it updates the match data, which
you can access using match-beginning and match-end.
See section 34.6 The Match Data.
In this example, point is located directly before the `T'. If it
were anywhere else, the result would be nil.
---------- Buffer: foo ----------
I read "-!-The cat in the hat
comes back" twice.
---------- Buffer: foo ----------
(looking-at "The cat in the hat$")
=> t
|
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The usual regular expression functions do backtracking when necessary to handle the `\|' and repetition constructs, but they continue this only until they find some match. Then they succeed and report the first match found.
This section describes alternative search functions which perform the full backtracking specified by the POSIX standard for regular expression matching. They continue backtracking until they have tried all possibilities and found all matches, so they can report the longest match, as required by POSIX. This is much slower, so use these functions only when you really need the longest match.
re-search-forward except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
re-search-backward except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
looking-at except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
string-match except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
query-replace and related
commands. It searches for occurrences of from-string in the
text between positions start and end and replaces some or
all of them. If start is nil, point is used instead, and
the buffer's end is used for end.
If query-flag is nil, it replaces all
occurrences; otherwise, it asks the user what to do about each one.
If regexp-flag is non-nil, then from-string is
considered a regular expression; otherwise, it must match literally. If
delimited-flag is non-nil, then only replacements
surrounded by word boundaries are considered.
The argument 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 replacements is a cons cell, (function
. data), this means to call function after each match to
get the replacement text. This function is called with two arguments:
data, and the number of replacements already made.
If repeat-count is non-nil, it should be an integer. Then
it specifies how many times to use each of the strings in the
replacements list before advancing cyclicly to the next one.
If from-string contains upper-case letters, then
perform-replace binds case-fold-search to nil, and
it uses the replacements without altering the case of them.
Normally, the keymap query-replace-map defines the possible user
responses for queries. The argument map, if non-nil, is a
keymap to use instead of query-replace-map.
query-replace and related functions, as well as
y-or-n-p and map-y-or-n-p. It is unusual in two ways:
read-key-sequence to get the input; instead, they read a single
event and look it up "by hand."
Here are the meaningful "bindings" for query-replace-map.
Several of them are meaningful only for query-replace and
friends.
act
skip
exit
act-and-exit
act-and-show
automatic
backup
edit
delete-and-edit
recenter
quit
y-or-n-p and related functions
use this answer.
help
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
Because the match data normally describe the most recent search only, you must be careful not to do another search inadvertently between the search you wish to refer back to and the use of the match data. If you can't avoid another intervening search, you must save and restore the match data around it, to prevent it from being overwritten.
34.6.1 Replacing the Text that Matched Replacing a substring that was matched. 34.6.2 Simple Match Data Access Accessing single items of match data, such as where a particular subexpression started. 34.6.3 Accessing the Entire Match Data Accessing the entire match data at once, as a list. 34.6.4 Saving and Restoring the Match Data Saving and restoring the match data.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This function replaces the text matched by the last search with replacement.
If you did the last search in a buffer, you should specify nil
for string. Then replace-match does the replacement by
editing the buffer; it leaves point at the end of the replacement text,
and returns t.
If you did the search in a string, pass the same string as string.
Then replace-match does the replacement by constructing and
returning a new string.
If fixedcase is non-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, replace-match considers this a capitalized first word
rather than all upper case.
If literal is non-nil, then replacement is inserted
exactly as it is, the only alterations being case changes as needed.
If it is nil (the default), then the character `\' is treated
specially. If a `\' appears in replacement, then it must be
part of one of the following sequences:
If subexp is non-nil, that says to replace just
subexpression number subexp of the regexp that was matched, not
the entire match. For example, after matching `foo \(ba*r\)',
calling replace-match with 1 as subexp means to replace
just the text that matched `\(ba*r\)'.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section explains how to use the match data to find out what was matched by the last search or match operation.
You can ask about the entire matching text, or about a particular parenthetical subexpression of a regular expression. The count argument in the functions below specifies which. If count is zero, you are asking about the entire match. If count is positive, it specifies which subexpression you want.
Recall that the subexpressions of a regular expression are those expressions grouped with escaped parentheses, `\(...\)'. The countth subexpression is found by counting occurrences of `\(' from the beginning of the whole regular expression. The first subexpression is numbered 1, the second 2, and so on. Only regular expressions can have subexpressions--after a simple string search, the only information available is about the entire match.
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.
If the last such operation was done against a string with
string-match, then you should pass the same string as the
argument in-string. After a buffer search or match,
you should omit in-string or pass nil for it; but you
should make sure that the current buffer when you call
match-string is the one in which you did the searching or
matching.
The value is nil if count is out of range, or for a
subexpression inside a `\|' alternative that wasn't used or a
repetition that repeated zero times.
match-string except that the result
has no text properties.
If count is zero, then the value is the position of the start of the entire match. Otherwise, count specifies a subexpression in the regular expression, and the value of the function is the starting position of the match for that subexpression.
The value is nil for a subexpression inside a `\|'
alternative that wasn't used or a repetition that repeated zero times.
match-beginning except that it returns the
position of the end of the match, rather than the position of the
beginning.
Here is an example of using the match data, with a comment showing the positions within the text:
(string-match "\\(qu\\)\\(ick\\)"
"The quick fox jumped quickly.")
;0123456789
=> 4
(match-string 0 "The quick fox jumped quickly.")
=> "quick"
(match-string 1 "The quick fox jumped quickly.")
=> "qu"
(match-string 2 "The quick fox jumped quickly.")
=> "ick"
(match-beginning 1) ; The beginning of the match
=> 4 ; with `qu' is at index 4.
(match-beginning 2) ; The beginning of the match
=> 6 ; with `ick' is at index 6.
(match-end 1) ; The end of the match
=> 6 ; with `qu' is at index 6.
(match-end 2) ; The end of the match
=> 9 ; with `ick' is at index 9.
|
Here is another example. Point is initially located at the beginning of the line. Searching moves point to between the space and the word `in'. The beginning of the entire match is at the 9th character of the buffer (`T'), and the beginning of the match for the first subexpression is at the 13th character (`c').
(list
(re-search-forward "The \\(cat \\)")
(match-beginning 0)
(match-beginning 1))
=> (9 9 13)
---------- Buffer: foo ----------
I read "The cat -!-in the hat comes back" twice.
^ ^
9 13
---------- Buffer: foo ----------
|
(In this case, the index returned is a buffer position; the first character of the buffer counts as 1.)
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The functions match-data and set-match-data read or
write the entire match data, all at once.
(match-beginning n); and
element
number 2n + 1
corresponds to (match-end n).
All the elements are markers or nil if matching was done on a
buffer, and all are integers or nil if matching was done on a
string with string-match.
As always, there must be no possibility of intervening searches between
the call to a search function and the call to match-data that is
intended to access the match data for that search.
(match-data)
=> (#<marker at 9 in foo>
#<marker at 17 in foo>
#<marker at 13 in foo>
#<marker at 17 in foo>)
|
match-data.
If 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.
store-match-data is a semi-obsolete alias for set-match-data.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
When you call a function that may do a search, you may need to save and restore the match data around that call, if you want to preserve the match data from an earlier search for later use. Here is an example that shows the problem that arises if you fail to save the match data:
(re-search-forward "The \\(cat \\)")
=> 48
(foo) ; Perhaps |
You can save and restore the match data with save-match-data:
You could use set-match-data together with match-data to
imitate the effect of the special form save-match-data. Here is
how:
(let ((data (match-data)))
(unwind-protect
... ; Ok to change the original match data.
(set-match-data data)))
|
Emacs automatically saves and restores the match data when it runs process filter functions (see section 37.9.2 Process Filter Functions) and process sentinels (see section 37.10 Sentinels: Detecting Process Status Changes).
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
By default, searches in Emacs ignore the case of the text they are searching through; if you specify searching for `FOO', then `Foo' or `foo' is also considered a match. This applies to regular expressions, too; thus, `[aB]' would match `a' or `A' or `b' or `B'.
If you do not want this feature, set the variable
case-fold-search to nil. Then all letters must match
exactly, including case. This is a buffer-local variable; altering the
variable affects only the current buffer. (See section 11.10.1 Introduction to Buffer-Local Variables.) Alternatively, you may change the value of
default-case-fold-search, which is the default value of
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.
nil, that means to use the
replacement text verbatim. A non-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
replace-match. See section 34.6.1 Replacing the Text that Matched.
nil they do not ignore case; otherwise
they do ignore case.
case-fold-search in buffers that do not override it. This is the
same as (default-value 'case-fold-search).
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section describes some variables that hold regular expressions used for certain purposes in editing:
"^\014" (i.e., "^^L" or
"^\C-l"); this matches a line that starts with a formfeed
character.
The following two regular expressions should not assume the match always starts at the beginning of a line; they should not use `^' to anchor the match. Most often, the paragraph commands do check for a match only at the beginning of a line, which means that `^' would be superfluous. When there is a nonzero left margin, they accept matches that start after the left margin. In that case, a `^' would be incorrect. However, a `^' is harmless in modes where a left margin is never used.
paragraph-start also.) The default value is
"[ \t\f]*$", which matches a line that consists entirely of
spaces, tabs, and form feeds (after its left margin).
"[ \t\n\f]", which matches a line starting with a space, tab,
newline, or form feed (after its left margin).
"[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*" |
This means a period, question mark or exclamation mark, followed optionally by a closing parenthetical character, followed by tabs, spaces or new lines.
For a detailed explanation of this regular expression, see 34.2.2 Complex Regexp Example.
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |