[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44. Searching and Matching

XEmacs 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.

44.1 Searching for Strings  Search for an exact match.
44.2 Regular Expressions  Describing classes of strings.
44.3 Regular Expression Searching  Searching for a match for a regexp.
44.4 POSIX Regular Expression Searching  Searching POSIX-style for the longest match.
44.5 Search and Replace  Internals of query-replace.
44.6 The Match Data  Finding out which part of the text matched various parts of a regexp, after regexp search.
44.7 Searching and Case  Case-independent or case-significant searching.
44.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 41.2.7 Skipping Characters.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.1 Searching for Strings

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; limit and noerror are set to nil, and count is set to 1.

Command: search-forward string &optional limit noerror count buffer
This function searches forward from point for an exact match for string. If successful, it sets point to the end of the occurrence found, and returns the new value of point. If no match is found, the value and side effects depend on noerror (see below).

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 programs may depend on a value of nil.)

If count is supplied (it must be a fixnum), then the search is repeated that many times (each time starting at the end of the previous time's match). If count is negative, the search direction is backward. If the successive searches succeed, the function succeeds, moving point and returning its new value. Otherwise the search fails.

buffer is the buffer to search in, and defaults to the current buffer.

Command: search-backward string &optional limit noerror count buffer
This function searches backward from point for string. It is just like search-forward except that it searches backwards and leaves point at the beginning of the match.

Command: word-search-forward string &optional limit noerror count buffer
This function searches forward from point for a "word" match for string. If it finds a match, it sets point to the end of the match found, and returns the new value of point.

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 count is non-nil, then the search is repeated that many times. Point is positioned at the end of the last match.

buffer is the buffer to search in, and defaults to the current buffer.

Command: word-search-backward string &optional limit noerror count buffer
This function searches backward from point for a word match to string. This function is just like word-search-forward except that it searches backward and normally leaves point at the beginning of the match.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.2 Regular Expressions

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.

To gain a thorough understanding of regular expressions and how to use them to best advantage, we recommend that you study Mastering Regular Expressions, by Jeffrey E.F. Friedl, O'Reilly and Associates, 1997. (It's known as the "Hip Owls" book, because of the picture on its cover.) You might also read the manuals to @xref{(gawk)Top}, @xref{(ed)Top}, sed, grep, @xref{(perl)Top}, @xref{(regex)Top}, @xref{(rx)Top}, pcre, and @xref{(flex)Top}, which also make good use of regular expressions.

The XEmacs regular expression syntax most closely resembles that of ed, or grep, the GNU versions of which all utilize the GNU regex library. XEmacs' version of regex has recently been extended with some Perl--like capabilities, described in the next section.

44.2.1 Syntax of Regular Expressions  Rules for writing regular expressions.
44.2.2 Complex Regexp Example  Illustrates regular expression syntax.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.2.1 Syntax of Regular Expressions

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 `ff'.) 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 characters. Here is a list of them:

. (Period)
is a special character that matches any single character except a newline. Using concatenation, we can make regular expressions like `a.b', which matches any three-character string that begins with `a' and ends with `b'.

*
is not a construct by itself; it is a quantifying suffix operator that means to repeat the preceding regular expression as many times as possible. In `fo*', the `*' applies to the `o', so `fo*' matches one `f' followed by any number of `o's. The case of zero `o's is allowed: `fo*' does match `f'.

`*' always applies to the smallest possible preceding expression. Thus, `fo*' has a repeating `o', not a repeating `fo'.

The matcher processes a `*' construct by matching, immediately, as many repetitions as can be found; it is "greedy". Then it continues with the rest of the pattern. If that fails, backtracking occurs, discarding some of the matches of the `*'-modified construct in case that makes 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 match the sequence `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz'. 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.

+
is a quantifying suffix operator similar to `*' except that the preceding expression must match at least once. It is also "greedy". So, for example, `ca+r' matches the strings `car' and `caaaar' but not the string `cr', whereas `ca*r' matches all three strings.

?
is a quantifying suffix operator similar to `*', except that the preceding expression can match either once or not at all. For example, `ca?r' matches `car' or `cr', but does not match anything else.

*?
works just like `*', except that rather than matching the longest match, it matches the shortest match. `*?' is known as a non-greedy quantifier, a regexp construct borrowed from Perl.

This construct is very useful for when you want to match the text inside a pair of delimiters. For instance, `/\*.*?\*/' will match C comments in a string. This could not easily be achieved without the use of a non-greedy quantifier.

This construct has not been available prior to XEmacs 20.4. It is not available in FSF Emacs.

+?
is the non-greedy version of `+'.

??
is the non-greedy version of `?'.

\{n,m\}
serves as an interval quantifier, analogous to `*' or `+', but specifies that the expression must match at least n times, but no more than m times. This syntax is supported by most Unix regexp utilities, and has been introduced to XEmacs for the version 20.3.

Unfortunately, the non-greedy version of this quantifier does not exist currently, although it does in Perl.

[ ... ]
`[' begins a character set, which is terminated by a `]'. In the simplest case, the characters between the two brackets form the set. 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.

The usual regular expression special characters are not special inside a character set. A completely different set of special characters exists inside character sets: `]', `-' and `^'.

`-' is used for ranges of characters. To write a range, write two characters with a `-' between them. Thus, `[a-z]' matches any lower case letter. Ranges may be intermixed freely with individual characters, as in `[a-z$%.]', which matches any lower case letter or `$', `%', or a period.

To include a `]' in a character set, make it the first character. For example, `[]a]' matches `]' or `a'. To include a `-', write `-' as the first character in the set, or put it immediately after a range. (You can replace one individual character c with the range `c-c' to make a place to put the `-'.) There is no way to write a set containing just `-' and `]'.

To include `^' in a set, put it anywhere but at the beginning of the set.

[^ ... ]
`[^' begins a complement character set, which matches any character except the ones specified. Thus, `[^a-z0-9A-Z]' matches all characters except letters and digits.

`^' is not special in a character set unless it is the first character. The character following the `^' is treated as if it were first (thus, `-' and `]' are not special there).

Note that a complement character set can match a newline, unless newline is mentioned as one of the characters not to match.

^
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, `^foo' matches a `foo' that occurs at the beginning of a line.

When matching a string instead of a buffer, `^' matches at the beginning of the string or after a newline character `\n'.

$
is similar to `^' but matches only at the end of a line. Thus, `x+$' matches a string of one `x' or more at the end of a line.

When matching a string instead of a buffer, `$' matches at the end of the string or before a newline character `\n'.

\
has two functions: it quotes the special characters (including `\'), and it introduces additional special constructs.

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 8.4.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.

For the most part, `\' followed by any character matches only that character. However, there are several exceptions: characters that, when preceded by `\', are special constructs. Such characters are always ordinary when encountered on their own. Here is a table of `\' constructs:

\|
specifies an alternative. Two regular expressions a and b with `\|' in between form an expression that matches anything that either a or b matches.

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 `\|'.

\( ... \)
is a grouping construct that serves three purposes:

  1. To enclose a set of `\|' alternatives for other operations. Thus, `\(foo\|bar\)x' matches either `foox' or `barx'.

  2. To enclose an expression for a suffix operator such as `*' to act on. Thus, `ba\(na\)*' matches `bananana', etc., with any (zero or more) number of `na' strings.

  3. To record a matched substring for future reference.

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 `\( ... \)' construct because there is no conflict in practice between the two meanings. Here is an explanation of this feature:

\digit
matches the same text that matched the digitth occurrence of a `\( ... \)' construct.

In other words, after the end of a `\( ... \)' 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 `\' followed by digit to match that same text, whatever it may have been.

The strings matching the first nine `\( ... \)' 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 `\1' through `\9' to refer to the text matched by the corresponding `\( ... \)' 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.

\(?: ... \)
is called a shy grouping operator, and it is used just like `\( ... \)', except that it does not cause the matched substring to be recorded for future reference.

This is useful when you need a lot of grouping `\( ... \)' constructs, but only want to remember one or two -- or if you have more than nine groupings and need to use backreferences to refer to the groupings at the end. It also allows construction of regular expressions from variable subexpressions that contain varying numbers of non-capturing subexpressions, without disturbing the group counts for the main expression. For example

 
(let ((sre (if foo "\\(?:bar\\|baz\\)" "quux")))
  (re-search-forward (format "a\\(b+ %s c+\\) d" sre) nil t)
  (match-string 1))

It is very tedious to write this kind of code without shy groups, even if you know what all the alternative subexpressions will look like.

Using `\(?: ... \)' rather than `\( ... \)' should give little performance gain, as the start of each group must be recorded for the purpose of back-tracking in any case, and no string copying is done until match-string is called.

The shy grouping operator has been borrowed from Perl, and was not available prior to XEmacs 20.3, and has only been available in GNU Emacs since version 21.

\w
matches any word-constituent character. The editor syntax table determines which characters these are. See section 45. Syntax Tables.

\W
matches any character that is not a word constituent.

\scode
matches any character whose syntax is code. Here code is a character that represents a syntax code: thus, `w' for word constituent, `-' for whitespace, `(' for open parenthesis, etc. See section 45. Syntax Tables, for a list of syntax codes and the characters that stand for them.

\Scode
matches any character whose syntax is not code.

\ccategory
matches any character in category. Only available under Mule, categories, and category tables, are further described in 63.8 Category Tables. They are a mechanism for constructing classes of characters that can be local to a buffer, and that do not require complicated [] expressions every time they are referenced.

\Ccategory
matches any character outside category. See section 63.8 Category Tables, again, and note that this is only available under Mule.

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.

\`
matches the empty string, but only at the beginning of the buffer or string being matched against.

\'
matches the empty string, but only at the end of the buffer or string being matched against.

\=
matches the empty string, but only at point. (This construct is not defined when matching against a string.)

\b
matches the empty string, but only at the beginning or end of a word. Thus, `\bfoo\b' matches any occurrence of `foo' as a separate word. `\bballs?\b' matches `ball' or `balls' as a separate word.

\B
matches the empty string, but not at the beginning or end of a word.

\<
matches the empty string, but only at the beginning of a word.

\>
matches the empty string, but only at the end of a word.

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.

Function: regexp-quote string
This function returns a regular expression string that matches exactly string and nothing else. This allows you to request an exact string match 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-"))


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.2.2 Complex Regexp Example

Here is a complicated regexp, used by XEmacs 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:

[.?!]
The first part of the pattern is a character set that matches any one of three characters: period, question mark, and exclamation mark. The match must begin with one of these three characters.

[]\"')}]*
The second part of the pattern matches any closing braces and quotation marks, zero or more of them, that may follow the period, question mark or exclamation mark. The \" is Lisp syntax for a double-quote in a string. The `*' at the end indicates that the immediately preceding regular expression (a character set, in this case) may be repeated zero or more times.

\\($\\| $\\|\t\\|  \\)
The third part of the pattern matches the whitespace that follows the end of a sentence: the end of a line, or a tab, or two spaces. The double backslashes mark the parentheses and vertical bars as regular expression syntax; the parentheses delimit a group and the vertical bars separate alternatives. The dollar sign is used to match the end of a line.

[ \t\n]*
Finally, the last part of the pattern matches any additional whitespace beyond the minimum needed to end a sentence.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.3 Regular Expression Searching

In XEmacs, you can search for the next match for a regexp either incrementally or not. Incremental search commands are described in the The XEmacs Lisp Reference Manual. See section `Regular Expression Search' in The XEmacs Lisp Reference Manual. Here we describe only the search functions useful in programs. The principal one is re-search-forward.

Command: re-search-forward regexp &optional limit noerror count buffer
This function searches forward in the current buffer for a string of text that is matched by the regular expression regexp. The function skips over any amount of text that is not matched by regexp, and leaves point at the end of the first match found. It returns the new value of point.

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.

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, 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.

If count 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.

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 ----------

Command: re-search-backward regexp &optional limit noerror count buffer
This function searches backward in the current buffer for a string of text that is matched by the regular expression regexp, leaving point at the beginning of the first text found.

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 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 regexps from end to beginning. It's not worth the trouble of implementing that.

Function: string-match regexp string &optional start buffer
This function returns the index of the start of the first match for the regular expression regexp in string, or nil if there is no match. If start is non-nil, the search starts at that index in string.

Optional arg buffer controls how case folding is done (according to the value of case-fold-search in buffer and buffer's case tables) and defaults to the current buffer.

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 44.6 The Match Data.

 
(string-match
 "quick" "The quick brown fox jumped quickly." 8)
     => 27

(match-end 0)
     => 32

The function split-string can be used to parse a string into components delimited by text matching a regular expression.

Variable: split-string-default-separators
The default value of separators for split-string, initially `"[ \f\t\n\r\v]+"'.

Function: split-string string &optional separators omit-nulls
This function splits string into substrings delimited by matches for the regular expression separators. Each match for separators defines a splitting point; the substrings between the splitting points are made into a list, which is the value returned by split-string. If omit-nulls is t, null strings will be removed from the result list. Otherwise, null strings are left in the result. If separators is nil (or omitted), the default is the value of split-string-default-separators.

As a special case, when separators is nil (or omitted), null strings are always omitted from the result. Thus:

 
(split-string "  two words ")
     => ("two" "words")

The result is not `("" "two" "words" "")', which would rarely be useful. If you need such a result, use an explict value for separators:

 
(split-string "  two words " split-string-default-separators)
     => ("" "two" "words" "")

A few examples (there are more in the regression tests):

 
(split-string "foo" "")
     => ("" "f" "o" "o" "")
(split-string "foo" "^")
     => ("" "foo")
(split-string "foo" "$")
     => ("foo" ""))
(split-string "foo,bar" ",")
     => ("foo" "bar")
(split-string ",foo,bar," ",")
     => ("" "foo" "bar" "")
(split-string ",foo,bar," "^,")
     => ("" "foo,bar,")
(split-string "foo,bar" "," t)
     => ("foo" "bar")
(split-string ",foo,bar," "," t)
     => ("foo" "bar")

Function: split-path path
This function splits a search path into a list of strings. The path components are separated with the characters specified with path-separator. Under Unix, path-separator will normally be `:', while under Windows, it will be `;'.

Function: looking-at regexp &optional buffer
This function determines whether the text in the current buffer directly following point matches the regular expression regexp. "Directly following" means precisely that: the search is "anchored" and it can succeed only starting with the first character following point. The result is 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 44.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] [ ? ]

44.4 POSIX Regular Expression Searching

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.

In Emacs versions prior to 19.29, these functions did not exist, and the functions described above implemented full POSIX backtracking.

Command: posix-search-forward regexp &optional limit noerror count buffer
This is like re-search-forward except that it performs the full backtracking specified by the POSIX standard for regular expression matching.

Command: posix-search-backward regexp &optional limit noerror count buffer
This is like re-search-backward except that it performs the full backtracking specified by the POSIX standard for regular expression matching.

Function: posix-looking-at regexp &optional buffer
This is like looking-at except that it performs the full backtracking specified by the POSIX standard for regular expression matching.

Function: posix-string-match regexp string &optional start buffer
This is like string-match except that it performs the full backtracking specified by the POSIX standard for regular expression matching.

Optional arg buffer controls how case folding is done (according to the value of case-fold-search in buffer and buffer's case tables) and defaults to the current buffer.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.5 Search and Replace

Function: perform-replace from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map
This function is the guts of query-replace and related commands. It searches for occurrences of from-string and replaces some or all of them. 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 repeat-count is non-nil, it should be a fixnum. Then it specifies how many times to use each of the strings in the replacements list before advancing cyclicly to the next one.

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.

Variable: query-replace-map
This variable holds a special keymap that defines the valid user responses for query-replace and related functions, as well as y-or-n-p and map-y-or-n-p. It is unusual in two ways:

Here are the meaningful "bindings" for query-replace-map. Several of them are meaningful only for query-replace and friends.

act
Do take the action being considered--in other words, "yes."

skip
Do not take action for this question--in other words, "no."

exit
Answer this question "no," and give up on the entire series of questions, assuming that the answers will be "no."

act-and-exit
Answer this question "yes," and give up on the entire series of questions, assuming that subsequent answers will be "no."

act-and-show
Answer this question "yes," but show the results--don't advance yet to the next question.

automatic
Answer this question and all subsequent questions in the series with "yes," without further user interaction.

backup
Move back to the previous place that a question was asked about.

edit
Enter a recursive edit to deal with this question--instead of any other action that would normally be taken.

delete-and-edit
Delete the text being considered, then enter a recursive edit to replace it.

recenter
Redisplay and center the window, then ask the same question again.

quit
Perform a quit right away. Only y-or-n-p and related functions use this answer.

help
Display some help, then ask again.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.6 The Match Data

XEmacs keeps track of the positions of the start and end of 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 successful 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.

To make it possible to write iterative or recursive code that repeatedly searches, and uses the data from the last successful search when no more matches can be found, a search or match which fails will preserve the match data from the last successful search. (You must not depend on match data being preserved in case the search or match signals an error.) If for some reason you need to clear the match data, you may use (store-match-data nil).

44.6.1 Simple Match Data Access  Accessing single items of match data, such as where a particular subexpression started.
44.6.2 Replacing the Text That Matched  Replacing a substring that was matched.
44.6.3 Accessing the Entire Match Data  Accessing the entire match data at once, as a list.
44.6.4 Saving and Restoring the Match Data  Saving and restoring the match data.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.6.1 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.

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.

Function: 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 count is zero, or just the portion corresponding to the countth parenthetical subexpression, if count is positive. If count is out of range, or if that subexpression didn't match anything, the value is nil.

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. Otherwise, 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.

Function: match-beginning count
This function returns the position of the start of text matched by the last regular expression searched for, or a subexpression of it.

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 in the match.

Function: match-end count
This function is like 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] [ ? ]

44.6.2 Replacing the Text That Matched

This function replaces the text matched by the last search with replacement.

Function: replace-match replacement &optional fixedcase literal string strbuffer
This function replaces the text in the buffer (or in string) that was matched by the last search. It replaces that text with replacement.

If you did the last search in a buffer, you should specify nil for string. (An error will be signaled if you don't.) 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. (An error will be signaled if you specify nil.) 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 case-replace is nil, then case conversion is not done, regardless of the value of fixedcase. See section 44.7 Searching and 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:

`\&'
`\&' stands for the entire text being replaced.

`\n'
`\n', where n is a digit, stands for the text that matched the nth subexpression in the original regexp. Subexpressions are those expressions grouped inside `\(...\)'.

`\\'
`\\' stands for a single `\' in the replacement text.

`\u'
`\u' means upcase the next character.

`\l'
`\l' means downcase the next character.

`\U'
`\U' means begin upcasing all following characters.

`\L'
`\L' means begin downcasing all following characters.

`\E'
`\E' means terminate the effect of any `\U' or `\L'.

Case changes made with `\u', `\l', `\U', and `\L' override all other case changes that may be made in the replaced text.

The fifth argument strbuffer may be a buffer to be used for syntax-table and case-table lookup. If strbuffer is not a buffer, the current buffer is used. When string is not a string, the buffer that the match occurred in has automatically been remembered and you do not need to specify it. string may also be an integer, specifying the index of the subexpression to match. When string is not an integer, the "subexpression" is 0, i.e., the whole match. An invalid-argument error will be signaled if you specify a buffer when string is nil, or specify a subexpression which was not matched.

It is not possible to specify both a buffer and a subexpression, but the idiom

 
(with-current-buffer buffer (replace-match ... integer))
may be used.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.6.3 Accessing the Entire Match Data

The functions match-data and set-match-data read or write the entire match data, all at once.

Function: match-data &optional integers reuse
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 number 2n corresponds to (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. However, if the optional first argument integers is non-nil, always use integers (rather than markers) to represent buffer positions.

If the optional second argument reuse is a list, reuse it as part of the value. If reuse is long enough to hold all the values, and if integers is non-nil, no new lisp objects are created.

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>)

Function: set-match-data match-list
This function sets the match data from the elements of match-list, which should be a list that was the value of a previous call to 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 an alias for set-match-data.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.6.4 Saving and Restoring the Match Data

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 foo does
                        ;   more searching.
(match-end 0)
     => 61              ; Unexpected result---not 48!

You can save and restore the match data with save-match-data:

Macro: save-match-data body...
This macro executes body, saving and restoring the match data around it.

Emacs automatically saves and restores the match data when it runs process filter functions (see section 56.9.2 Process Filter Functions) and process sentinels (see section 56.10 Sentinels: Detecting Process Status Changes).


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.7 Searching and Case

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. Regexps, and in particular character sets, are included: 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 16.9.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 Lisp functions use.

User Option: case-replace
This variable determines whether the replacement functions should preserve case. If the variable is 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.

The function replace-match is where this variable actually has its effect. See section 44.6.2 Replacing the Text That Matched.

User Option: case-fold-search
This buffer-local variable determines whether searches should ignore case. If the variable is nil they do not ignore case; otherwise they do ignore case.

Variable: default-case-fold-search
The value of this variable is the default value for case-fold-search in buffers that do not override it. This is the same as (default-value 'case-fold-search).


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

44.8 Standard Regular Expressions Used in Editing

This section describes some variables that hold regular expressions used for certain purposes in editing:

Variable: page-delimiter
This is the regexp describing line-beginnings that separate pages. The default value is "^\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.

Variable: paragraph-separate
This is the regular expression for recognizing the beginning of a line that separates paragraphs. (If you change this, you may have to change 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).

Variable: paragraph-start
This is the regular expression for recognizing the beginning of a line that starts or separates paragraphs. The default value is "[ \t\n\f]", which matches a line starting with a space, tab, newline, or form feed (after its left margin).

Variable: sentence-end
This is the regular expression describing the end of a sentence. (All paragraph boundaries also end sentences, regardless.) The default value is:

 
"[.?!][]\"')}]*\\($\\| $\\|\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 44.2.2 Complex Regexp Example.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by XEmacs Webmaster on August, 3 2012 using texi2html